The following plugin provides functionality available through Pipeline-compatible steps. Read more about how to integrate steps into your Pipeline in the Steps section of the Pipeline Syntax page.

For a list of other such plugins, see the Pipeline Steps Reference page.

Pipeline: Groovy Libraries

library: Load a library on the fly

Load a library dynamically rather than using @Library syntax. You may use global variables defined in the library thereafter:


library 'mylib@master'
usefulFunction()

You may also load classes defined in the library by selecting their fully-qualified names like properties on the return value of this step, then call static methods or call constructors as if they were a method named new:


def utils = library('mylib').com.mycorp.jenkins.Utils.new(this)
utils.handyStuff()
  • identifier : String
    A library name to load. Should normally match that of a predefined library. You can append a version after @. You may instead define a library inline here.
  • changelog : boolean (optional)
    Whether to include any changes in the library in the recent changes of jobs using the library. Defaults to including the changes.
  • retriever (optional)
      Nested Choice of Objects
    • http
      Loads a library from a HTTP URL.
      • httpURL : String
        Define the HTTP URL where to get the shared libraries.
      • credentialsId : String
        Define credentials to retrieve the shared libraries through the defined HTTP URL, if needed.
      • preemptiveAuth : boolean
        To force using authentication when downloading the library archive. Can be useful if the HTTP server hides the existence of unauthorized resources by sending a 404 response (not found) to requests for resources that are not accessible by the user. Otherwise, the response implies that the resource exists, but is protected, by requesting authentication for anonymous requests (401), or by denying an authenticated request for unauthorized users.
    • nexus
      Loads a library from Nexus. The plugin needs to have the ~/.m2/settings.xml configured for authenticating with Nexus.
      • artifactDetails : String
        Define the artifact to download from Nexus, e.g.:
        - com.roylenferink:jenkins-shared-library:${library.jenkins-library.version}:zip:lib will become com.roylenferink:jenkins-shared-library:1.0.0-SNAPSHOT:zip:lib
        This assumes the library is configured as 'jenkins-library'.
      • mavenHome : String
        Define the directory of the Maven installation to be used, for example:
        - /usr/local/maven_3.9.0/

        This directory must contain a bin directory containing the mvn executable.
    • legacySCM
      • scm
          Nested Choice of Objects
        • $class: 'AWSCodePipelineSCM'
          • name : String
          • clearWorkspace : boolean
          • region : String

            The AWS region must be the same to the region where your action runs in CodePipeline. Examples: "us-east-1", "cn-north-1", "us-gov-west-1". To list all supported regions, see AWS CodePipeline endpoints and quotas.

          • awsAccessKey : String

            In order to integrate with AWS CodePipeline, you must authorize access to the pipeline and its related artifacts. If you installed Jenkins on a supported Amazon EC2 instance type, such as Amazon Linux, you can install the AWS CLI and configure a profile with the required credentials. This is the preferred method. In all other cases, you can store AWS credentials in these fields. You should securely configure your Jenkins instance to use HTTPS so that these credentials are not sent unencrypted.

          • awsSecretKey : String

            >In order to integrate with AWS CodePipeline, you must authorize access to the pipeline and its related artifacts. If you installed Jenkins on a supported Amazon EC2 instance type, such as Amazon Linux, you can install the AWS CLI and configure a profile with the required credentials. This is the preferred method. In all other cases, you can store AWS credentials in these fields. You should securely configure your Jenkins instance to use HTTPS so that these credentials are not sent unencrypted.

          • proxyHost : String

            You might need a proxy host address if you are hosting Jenkins on a private network. The proxy name can be an IP address or DNS address. The AWS CodePipeline Plugin for Jenkins requires internet access. If access is not configured, you might see errors in the AWS CodePipeline Polling Log.

          • proxyPort : String

            You might need a proxy port for your proxy host address if you are hosting Jenkins on a private network. The proxy port is a number, might be on port 8080, 3128, or 8443, depending on your network protocols and security settings. If access is not configured, you might see errors in the AWS CodePipeline Polling Log.

          • category : String

            This is the category of the action type in AWS CodePipeline, and is usually either Build or Test. To see an example usage, see Install and Configure the AWS CodePipeline Plugin for Jenkins.

          • provider : String

            This is the provider name of the action type in AWS CodePipeline. You must provide this exact string when adding an action for Jenkins in AWS CodePipeline. To see an example usage, see Install and Configure the AWS CodePipeline Plugin for Jenkins.

          • version : String

            Leave the default as 1.

        • accurev
          • depot : String
          • stream : String
          • serverName : String (optional)
          • serverUUID : String (optional)
          • wspaceORreftree : String (optional)
          • accurevTool : String (optional)
          • cleanreftree : boolean (optional)
          • directoryOffset : String (optional)
          • dontPopContent : boolean (optional)
          • filterForPollSCM : String (optional)
          • ignoreStreamParent : boolean (optional)
          • reftree : String (optional)
          • snapshotNameFormat : String (optional)
          • subPath : String (optional)
          • subPathOnly : boolean (optional)
          • synctime : boolean (optional)
          • useSnapshot : boolean (optional)
          • workspace : String (optional)
        • $class: 'BazaarSCM'
          • source : String
          • cleantree : boolean
          • browser
              Nested Choice of Objects
            • $class: 'Loggerhead'
              • url : String
                Loggerhead is a web-based interface for Bazaar branches. It is used by Launchpad, so if your code is hosted on Launchpad, you are using Loggerhead.
                The repository browser URL for the root of the project. For example, a Launchpad project called myproject would use http://bazaar.launchpad.net/~myteam/myproject/mybranch.
            • $class: 'OpenGrok'
              • url : String
                The repository browser URL for the root of the project. For example, the OpenGrok project would use http://src.opensolaris.org/source/.
              • rootModule : String
                Specify the root Bazaar module that this OpenGrok monitors. For example, for http://src.opensolaris.org/source/xref/opengrok/trunk/, this field would be opengrok/trunk/ because it displays the directory "/opengrok/trunk/".
          • checkout : boolean
        • $class: 'BitKeeperSCM'
          • parent : String
          • localRepository : String
          • usePull : boolean
          • quiet : boolean
        • BbS
          • id : String
          • branches
              Array / List of Nested Object
            • name : String

              Specify the branches if you'd like to track a specific branch in a repository. If left blank, all branches will be examined for changes and built.

              The safest way is to use the refs/heads/<branchName> syntax. This way the expected branch is unambiguous.

              If your branch name has a / in it make sure to use the full reference above. When not presented with a full path the plugin will only use the part of the string right of the last slash. Meaning foo/bar will actually match bar.

              If you use a wildcard branch specifier, with a slash (e.g. release/), you'll need to specify the origin repository in the branch names to make sure changes are picked up. So e.g. origin/release/

              Possible options:

              • <branchName>
                Tracks/checks out the specified branch. If ambiguous the first result is taken, which is not necessarily the expected one. Better use refs/heads/<branchName>.
                E.g. master, feature1, ...
              • refs/heads/<branchName>
                Tracks/checks out the specified branch.
                E.g. refs/heads/master, refs/heads/feature1/master, ...
              • <remoteRepoName>/<branchName>
                Tracks/checks out the specified branch. If ambiguous the first result is taken, which is not necessarily the expected one.
                Better use refs/heads/<branchName>.
                E.g. origin/master
              • remotes/<remoteRepoName>/<branchName>
                Tracks/checks out the specified branch.
                E.g. remotes/origin/master
              • refs/remotes/<remoteRepoName>/<branchName>
                Tracks/checks out the specified branch.
                E.g. refs/remotes/origin/master
              • <tagName>
                This does not work since the tag will not be recognized as tag.
                Use refs/tags/<tagName> instead.
                E.g. git-2.3.0
              • refs/tags/<tagName>
                Tracks/checks out the specified tag.
                E.g. refs/tags/git-2.3.0
              • <commitId>
                Checks out the specified commit.
                E.g. 5062ac843f2b947733e6a3b105977056821bd352, 5062ac84, ...
              • ${ENV_VARIABLE}
                It is also possible to use environment variables. In this case the variables are evaluated and the result is used as described above.
                E.g. ${TREEISH}, refs/tags/${TAGNAME}, ...
              • <Wildcards>
                The syntax is of the form: REPOSITORYNAME/BRANCH. In addition, BRANCH is recognized as a shorthand of */BRANCH, '*' is recognized as a wildcard, and '**' is recognized as wildcard that includes the separator '/'. Therefore, origin/branches* would match origin/branches-foo but not origin/branches/foo, while origin/branches** would match both origin/branches-foo and origin/branches/foo.
              • :<regular expression>
                The syntax is of the form: :regexp. Regular expression syntax in branches to build will only build those branches whose names match the regular expression.
                Examples:
                • :^(?!(origin/prefix)).*
                  • matches: origin or origin/master or origin/feature
                  • does not match: origin/prefix or origin/prefix_123 or origin/prefix-abc
                • :origin/release-\d{8}
                  • matches: origin/release-20150101
                  • does not match: origin/release-2015010 or origin/release-201501011 or origin/release-20150101-something
                • :^(?!origin/master$|origin/develop$).*
                  • matches: origin/branch1 or origin/branch-2 or origin/master123 or origin/develop-123
                  • does not match: origin/master or origin/develop

          • credentialsId : String

            When running a job, Jenkins requires credentials to authenticate with Bitbucket Server. For example, to checkout the source code for builds. To do this, it needs credentials with access to the projects and repositories you want it to build from.

            You can provide Jenkins with credentials here by:

            • selecting credentials from the list
            • adding credentials as a Username with password (for the password, you can enter a Bitbucket Server password or a Bitbucket Server personal access token)

            In addition, you can provide Jenkins with SSH credentials below. If you do, Jenkins will use them for clone operations instead of the credentials you select here.

          • sshCredentialsId : String

            If specified, Jenkins will use these credentials to check out the source code for builds. If no SSH credentials are specified, Jenkins will use the basic credentials instead.

            To provide Jenkins with SSH credentials, you can:

            • choose credentials from the list
            • add credentials as a SSH Username with private key (the username must be "git")
          • extensions
              Array / List of Nested Choice of Objects
            • authorInChangelog
              The default behavior is to use the Git commit's "Committer" value in Jenkins' build changesets. If this option is selected, the Git commit's "Author" value would be used instead.
              • $class: 'BuildChooserSetting'
                When you are interested in using a job to build multiple heads (most typically multiple branches), you can choose how Jenkins choose what branches to build in what order.

                This extension point in Jenkins is used by many other plugins to control the job to build specific commits. When you activate those plugins, you may see them installing a custom strategy here.

                • buildChooser
                    Nested Choice of Objects
                  • $class: 'AlternativeBuildChooser'
                    • $class: 'AncestryBuildChooser'
                      • maximumAgeInDays : int
                      • ancestorCommitSha1 : String
                    • $class: 'DefaultBuildChooser'
                      • $class: 'DeflakeGitBuildChooser'
                        • $class: 'GerritTriggerBuildChooser'
                          • $class: 'InverseBuildChooser'
                        • buildSingleRevisionOnly
                          Disable scheduling for multiple candidate revisions.
                          If we have 3 branches:
                          ----A--.---.--- B
                                   \-----C
                          jenkins would try to build (B) and (C).
                          This behaviour disables this and only builds one of them.
                          It is helpful to reduce the load of the Jenkins infrastructure when the SCM system like Bitbucket or GitHub should decide what commits to build.
                          • changelogToBranch
                            This method calculates the changelog against the specified branch.
                            • options
                                Nested Object
                              • compareRemote : String
                                Name of the repository, such as origin, that contains the branch you specify below.
                              • compareTarget : String
                                The name of the branch within the named repository to compare against.
                          • checkoutOption
                            • timeout : int
                              Specify a timeout (in minutes) for checkout.
                              This option overrides the default timeout of 10 minutes.
                              You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                          • cleanBeforeCheckout
                            Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                            • deleteUntrackedNestedRepositories : boolean (optional)
                              Deletes untracked submodules and any other subdirectories which contain .git directories.
                          • cleanAfterCheckout
                            Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                            • deleteUntrackedNestedRepositories : boolean (optional)
                              Deletes untracked submodules and any other subdirectories which contain .git directories.
                          • cloneOption
                            • shallow : boolean
                              Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                            • noTags : boolean
                              Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                            • reference : String
                              Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                              This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                            • timeout : int
                              Specify a timeout (in minutes) for clone and fetch operations.
                              This option overrides the default timeout of 10 minutes.
                              You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                            • depth : int (optional)
                              Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                            • honorRefspec : boolean (optional)
                              Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                          • $class: 'CodeCommitURLHelper'
                            • credentialId : String

                              OPTIONAL: Select the credentials to use.
                              If not specified, defaults to the DefaultAWSCredentialsProviderChain behaviour - *FROM THE JENKINS INSTANCE*

                              In the latter case, usage of IAM Role Profiles seems not to work, thus relying on environment variables / system properties or the ~/.aws/credentials file, thus not recommended.

                            • repositoryName : String
                          • $class: 'DisableRemotePoll'
                            Git plugin uses git ls-remote polling mechanism by default when configured with a single branch (no wildcards!). This compare the latest built commit SHA with the remote branch without cloning a local copy of the repo.

                            If you don't want to / can't use this.

                            If this option is selected, polling will require a workspace and might trigger unwanted builds (see JENKINS-10131).
                            • $class: 'ExcludeFromChangeSet'
                              • $class: 'ExcludeFromPoll'
                                • lfs
                                  Enable git large file support for the workspace by pulling large files after the checkout completes. Requires that the controller and each agent performing an LFS checkout have installed `git lfs`.
                                  • $class: 'GitSCMChecksExtension'
                                    • verboseConsoleLog : boolean (optional)
                                      If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                  • $class: 'GitSCMStatusChecksExtension'
                                    • name : String (optional)
                                    • skip : boolean (optional)
                                    • skipProgressUpdates : boolean (optional)
                                    • suppressLogs : boolean (optional)
                                    • unstableBuildNeutral : boolean (optional)
                                  • $class: 'GitTagMessageExtension'
                                    If the revision checked out has a git tag associated with it, the tag name will be exported during the build as GIT_TAG_NAME.
                                    If a message was specified when creating the tag, then that message will be exported during the build as the GIT_TAG_MESSAGE environment variable.
                                    If no tag message was specified, the commit message will be used.
                                    If you ticked the Use most recent tag option, and the revision checked out has no git tag associated with it, the parent commits will be searched for a git tag, and the rules stated above will apply to the first parent commit with a git tag.

                                    If the revision has more than one tag associated with it, only the most recent tag will be taken into account, unless the refspec contains "refs/tags/" — i.e. builds are only triggered when certain tag names or patterns are matched — in which case the exact tag name that triggered the build will be used, even if it's not the most recent tag for this commit.
                                    For this reason, if you're not using a tag-specific refspec but you are using the "Create a tag for every build" behaviour, you should make sure that the build-tagging behaviour is configured to run after this "export git tag message" behaviour.

                                    Tag and commit messages which span multiple lines are no problem, though only the first 10000 lines of a tag's message will be exported.
                                    • useMostRecentTag : boolean (optional)
                                  • $class: 'IgnoreNotifyCommit'
                                    If checked, this repository will be ignored when the notifyCommit-URL is accessed regardless of if the repository matches or not.
                                    • localBranch
                                      If given, checkout the revision to build as HEAD on this branch.

                                      If selected, and its value is an empty string or "**", then the branch name is computed from the remote branch without the origin. In that case, a remote branch origin/master will be checked out to a local branch named master, and a remote branch origin/develop/new-feature will be checked out to a local branch named develop/newfeature.

                                      Please note that this has not been tested with submodules.

                                      • localBranch : String
                                    • $class: 'MessageExclusion'
                                      • excludedMessage : String
                                        If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed with message matched to Pattern when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.

                                        Exclusion uses Pattern matching

                                        .*\[maven-release-plugin\].*
                                        The example above illustrates that if only revisions with "[maven-release-plugin]" message in first comment line have been committed to the SCM a build will not occur.

                                        You can create more complex patterns using embedded flag expressions.
                                        (?s).*FOO.*
                                        This example will search FOO message in all comment lines.
                                    • $class: 'PathRestriction'
                                      If set, and Jenkins is set to poll for changes, Jenkins will pay attention to included and/or excluded files and/or folders when determining if a build needs to be triggered.

                                      Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.
                                      • includedRegions : String
                                        Each inclusion uses java regular expression pattern matching, and must be separated by a new line. An empty list implies that everything is included.

                                            myapp/src/main/web/.*\.html
                                            myapp/src/main/web/.*\.jpeg
                                            myapp/src/main/web/.*\.gif
                                          
                                        The example above illustrates that a build will only occur, if html/jpeg/gif files have been committed to the SCM. Exclusions take precedence over inclusions, if there is an overlap between included and excluded regions.
                                      • excludedRegions : String
                                        Each exclusion uses java regular expression pattern matching, and must be separated by a new line.

                                            myapp/src/main/web/.*\.html
                                            myapp/src/main/web/.*\.jpeg
                                            myapp/src/main/web/.*\.gif
                                          
                                        The example above illustrates that if only html/jpeg/gif files have been committed to the SCM a build will not occur.
                                    • perBuildTag
                                      Create a tag in the workspace for every build to unambiguously mark the commit that was built. You can combine this with Git publisher to push the tags to the remote repository.
                                      • $class: 'PreBuildMerge'
                                        These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                        • options
                                            Nested Object
                                          • mergeTarget : String
                                            The name of the branch within the named repository to merge to, such as master.
                                          • fastForwardMode (optional)
                                            Merge fast-forward mode selection.
                                            The default, --ff, gracefully falls back to a merge commit when required.
                                            For more information, see the Git Merge Documentation
                                            • Values: FF, FF_ONLY, NO_FF
                                          • mergeRemote : String (optional)
                                            Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                          • mergeStrategy (optional)
                                            Merge strategy selection. This feature is not fully implemented in JGIT.
                                            • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                      • pretestedIntegration
                                        • gitIntegrationStrategy
                                            Nested Choice of Objects
                                          • accumulated

                                            Accumulated Commit Strategy

                                            This strategy merges your commits with the --no-ff switch
                                            • shortCommitMessage : boolean (optional)
                                          • ffonly

                                            Fast Forward only (--ff-only) Strategy

                                            This strategy fast-forward only using the --ff-only switch - or fails
                                            • shortCommitMessage : boolean (optional)
                                          • squash

                                            Squashed Commit Strategy

                                            This strategy squashes all your commit on a given branch with the --squash option
                                          • integrationBranch : String

                                            What to specify

                                            The branch name must match your integration branch name. No trailing slash.

                                            Merge is performed the following way

                                            Squash commit
                                                        git checkout -B <Branch name> <Repository name>/<Branch name>
                                                        git merge --squash <Branch matched by git>
                                                        git commit -C <Branch matched by git>
                                            Accumulated commit
                                                        git checkout -B <Branch name> <Repository name>/<Branch name>
                                                        git merge -m <commitMsg> <Branch matched by git> --no-ff

                                            When changes are pushed to the integration branch?

                                            Changes are only ever pushed when the build results is SUCCESS

                                                        git push <Repository name> <Branch name>
                                          • repoName : String

                                            What to specify

                                            The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                            No trailing slash on repository name.

                                            Remember to specify this when working with NAMED repositories in Git

                                        • pruneStaleBranch
                                          Run "git remote prune" for each remote, to prune obsolete local branches.
                                          • pruneTags
                                            • pruneTags : boolean
                                          • $class: 'RelativeTargetDirectory'
                                            • relativeTargetDir : String
                                              Specify a local directory (relative to the workspace root) where the Git repository will be checked out. If left empty, the workspace root itself will be used.

                                              This extension should not be used in Jenkins Pipeline (either declarative or scripted). Jenkins Pipeline already provides standard techniques for checkout to a subdirectory. Use ws and dir in Jenkins Pipeline rather than this extension.

                                          • $class: 'ScmName'

                                            Unique name for this SCM. Needed when using Git within the Multi SCM plugin.

                                            • name : String
                                          • $class: 'SparseCheckoutPaths'

                                            Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                            • sparseCheckoutPaths
                                                Array / List of Nested Object
                                              • path : String
                                          • submodule
                                            • depth : int (optional)
                                              Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                            • disableSubmodules : boolean (optional)
                                              By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                            • parentCredentials : boolean (optional)
                                              Use credentials from the default remote of the parent project.
                                            • recursiveSubmodules : boolean (optional)
                                              Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                            • reference : String (optional)
                                              Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                              This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                              To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                git init --bare
                                                git remote add SubProject1 https://gitrepo.com/subproject1
                                                git remote add SubProject2 https://gitrepo.com/subproject2
                                                git fetch --all
                                                
                                            • shallow : boolean (optional)
                                              Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                            • threads : int (optional)
                                              Specify the number of threads that will be used to update submodules.
                                              If unspecified, the command line git default thread count is used.
                                            • timeout : int (optional)
                                              Specify a timeout (in minutes) for submodules operations.
                                              This option overrides the default timeout of 10 minutes.
                                              You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                            • trackingSubmodules : boolean (optional)
                                              Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                          • $class: 'UserExclusion'
                                            • excludedUsers : String
                                              If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed by users in this list when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.

                                              Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.

                                              Each exclusion uses exact string comparison and must be separated by a new line. User names are only excluded if they exactly match one of the names in this list.

                                              auto_build_user
                                              The example above illustrates that if only revisions by "auto_build_user" have been committed to the SCM a build will not occur.
                                          • $class: 'UserIdentity'
                                            • name : String

                                              If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                            • email : String

                                              If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                          • $class: 'WipeWorkspace'
                                            Delete the contents of the workspace before building, ensuring a fully fresh workspace.
                                          • gitTool : String
                                          • projectName : String

                                            Enter the name of the Bitbucket Server project containing the repository you want Jenkins to build from. To find a project, start typing. If it doesn't appear in the search results, the credentials that you've chosen may not have read access to it and you'll need to provide different credentials.

                                            To get Jenkins to build from a personal repository, enter a tilde (~) followed by repository owner's username. For example, ~jsmith.

                                          • repositoryName : String

                                            Enter the Bitbucket Server repository you want Jenkins to build from. To find a repository, start typing. If it doesn't appear in the search results, the credentials that you've chosen may not have read access to it and you'll need to provide different credentials.

                                            To get Jenkins to build from a personal repository, enter its slug. This is the URL-friendly version of the repository name. For example, a repository called my example repo will have the slug my-example-repo, and you can see this in its URL, https://bitbucketserver.mycompany.com/myproject/my-example-repo.

                                          • serverId : String

                                            Choose the Bitbucket Server instance containing the repository you want Jenkins to build from. If you can't find your instance, check this plugin's configuration and try again.

                                          • mirrorName : String

                                            Choose the location that Jenkins should clone from when running this build. This can be the primary server or a mirror if one is available. To see available mirrors, first choose a Bitbucket Server project and repository.

                                        • $class: 'BlameSubversionSCM'

                                          if it is false and the build is not triggered by upstream job,

                                          the plugin will not collect any svn info from upstream job.

                                          else the plugin will collect svn info from latest upstream job

                                          • alwaysCollectSVNInfo : boolean
                                        • $class: 'CCUCMScm'
                                        • $class: 'CVSSCM'
                                        • $class: 'ClearCaseSCM'
                                          • branch : String
                                          • label : String
                                          • extractConfigSpec : boolean
                                          • configSpecFileName : String
                                          • refreshConfigSpec : boolean
                                          • refreshConfigSpecCommand : String
                                          • configSpec : String
                                          • viewTag : String
                                          • useupdate : boolean
                                          • extractLoadRules : boolean
                                          • loadRules : String
                                          • useOtherLoadRulesForPolling : boolean
                                          • loadRulesForPolling : String
                                          • usedynamicview : boolean
                                          • viewdrive : String
                                          • mkviewoptionalparam : String
                                          • filterOutDestroySubBranchEvent : boolean
                                          • doNotUpdateConfigSpec : boolean
                                          • rmviewonrename : boolean
                                          • excludedRegions : String
                                          • multiSitePollBuffer : String
                                          • useTimeRule : boolean
                                          • createDynView : boolean
                                          • viewPath : String
                                          • changeset
                                            • Values: ALL, BRANCH, NONE, UPDT
                                          • viewStorage

                                            Three strategies are currently available to manage view storage location.

                                            • Default. This entry doesn't generate any additional argument to the cleartool mkview command. The behaviour will change depending on how your clearcase server is configured.
                                            • Use server storage location. This entry generates a -stgloc argument to the cleartool mkview command.
                                            • Use explicit path. This entry generates a -vws argument to the cleartool mkview command.

                                              Nested Choice of Objects
                                            • $class: 'DefaultViewStorage'
                                              • $class: 'ServerViewStorage'
                                                • assignedLabelString : String

                                                  Label expression used to populate view storage location dropdown.

                                                • server : String

                                                  The view storage location that will be passed to the -stgloc option.
                                                  The list of available servers is retrieved using cleartool lsstgloc -view
                                                  Note that auto is always available.

                                              • $class: 'SpecificViewStorage'
                                                • winStorageDir : String
                                                • unixStorageDir : String
                                          • $class: 'ClearCaseUcmBaselineSCM'
                                            When used (and fully set up), this option will display a field at build-time so that the user is able to select a ClearCase UCM baseline from which to download the content for this project.
                                            • $class: 'ClearCaseUcmSCM'
                                              • stream : String
                                              • loadrules : String
                                              • viewTag : String
                                              • usedynamicview : boolean
                                              • viewdrive : String
                                              • mkviewoptionalparam : String
                                              • filterOutDestroySubBranchEvent : boolean
                                              • useUpdate : boolean
                                              • rmviewonrename : boolean
                                              • excludedRegions : String
                                              • multiSitePollBuffer : String
                                              • overrideBranchName : String
                                              • createDynView : boolean
                                              • freezeCode : boolean
                                              • recreateView : boolean
                                              • allocateViewName : boolean
                                              • viewPath : String
                                              • useManualLoadRules : boolean
                                              • changeset
                                                • Values: ALL, BRANCH, NONE, UPDT
                                              • viewStorage

                                                Three strategies are currently available to manage view storage location.

                                                • Default. This entry doesn't generate any additional argument to the cleartool mkview command. The behaviour will change depending on how your clearcase server is configured.
                                                • Use server storage location. This entry generates a -stgloc argument to the cleartool mkview command.
                                                • Use explicit path. This entry generates a -vws argument to the cleartool mkview command.

                                                  Nested Choice of Objects
                                                • $class: 'DefaultViewStorage'
                                                  • $class: 'ServerViewStorage'
                                                    • assignedLabelString : String

                                                      Label expression used to populate view storage location dropdown.

                                                    • server : String

                                                      The view storage location that will be passed to the -stgloc option.
                                                      The list of available servers is retrieved using cleartool lsstgloc -view
                                                      Note that auto is always available.

                                                  • $class: 'SpecificViewStorage'
                                                    • winStorageDir : String
                                                    • unixStorageDir : String
                                                • buildFoundationBaseline : boolean

                                                  If checked, instead of creating a view on the current stream, the job will look up the current foundation baselines for the given stream and work in readonly on these baselines. If polling is enabled, the build will be triggered every time a new foundation baseline is detected on the given stream.

                                              • $class: 'CloneWorkspaceSCM'
                                                • parentJobName : String
                                                • criteria : String
                                              • $class: 'CmvcSCM'
                                                • family : String
                                                • become : String
                                                • releases : String
                                                • checkoutScript : String
                                                • trackViewReportWhereClause : String
                                              • $class: 'CvsProjectset'
                                              • $class: 'DarcsScm'
                                                • source : String
                                                • localDir : String
                                                • clean : boolean
                                                • browser
                                                    Nested Choice of Objects
                                                  • $class: 'DarcsWeb'
                                                    • url : String
                                                    • repo : String
                                                  • $class: 'Darcsden'
                                                    • url : String
                                              • $class: 'DimensionsSCM'
                                                • project : String
                                                • credentialsType : String
                                                • userName : String
                                                • password : String
                                                • pluginServer : String
                                                • userServer : String
                                                • keystoreServer : String
                                                • pluginDatabase : String
                                                • userDatabase : String
                                                • keystoreDatabase : String
                                                • keystorePath : String
                                                • certificateAlias : String
                                                • credentialsId : String
                                                • certificatePassword : String
                                                • keystorePassword : String
                                                • certificatePath : String
                                                • remoteCertificatePassword : String
                                                • secureAgentAuth : boolean
                                                • canJobDelete : boolean (optional)
                                                • canJobExpand : boolean (optional)
                                                • canJobForce : boolean (optional)
                                                • canJobNoMetadata : boolean (optional)
                                                • canJobNoTouch : boolean (optional)
                                                • canJobRevert : boolean (optional)
                                                • canJobUpdate : boolean (optional)
                                                • eol : String (optional)
                                                • folders (optional)
                                                    Array / List of Nested Object
                                                  • value : String
                                                • pathsToExclude (optional)
                                                    Array / List of Nested Object
                                                  • value : String
                                                • permissions : String (optional)
                                                • timeZone : String (optional)
                                                • webUrl : String (optional)
                                              • $class: 'DrushMakefileSCM'
                                                • makefile : String

                                                  Specify the content of the Makefile. Support for YAML Makefiles depends on the version of Drush you have installed.

                                                  This example will generate a vanilla Drupal 7.38:

                                                      api=2
                                                      core=7.x
                                                      projects[drupal][version]=7.38
                                                      

                                                • root : String
                                                  Specify a local directory for the Drupal root (relative to the workspace root).
                                              • $class: 'EndevorConfiguration'
                                                • connectionId : String
                                                • filterPattern : String
                                                • fileExtension : String
                                                • credentialsId : String
                                                • targetFolder : String
                                              • filesystem
                                                • path : String

                                                  The file path for the source code.

                                                  e.g. \\Server1\project1\src or c:\myproject\src

                                                  Note for distributed build environment, please make sure the path is accessible on remote node(s)

                                                • clearWorkspace : boolean

                                                  If true, the system will delete all existing files/sub-folders in workspace before checking-out. Poll changes will not be affected by this setting.

                                                • copyHidden : boolean

                                                  If true, the system will copy hidden files and folders as well. Default is false.

                                                • filterSettings
                                                    Nested Object
                                                  • includeFilter : boolean
                                                  • selectors

                                                    You can apply wildcard filter(s) when detecting changes and copying files. By default, the system will filter out hidden files, on Unix, that means files/folder starting with ".", on Windows, that means files/folders with "hidden" attribute. You may want to filter out, e.g. files with ".tmp" extension.

                                                    Note: filters are applied on both sides, source and destination (i.e. the workspace). E.g. if you filter out ".tmp" files, all ".tmp" files currently in workspace will not be removed.

                                                      Array / List of Nested Object
                                                    • wildcard : String

                                                      ANT style wildcard.

                                                      To include just *.java, set filter type to "Include" and type add "*.java" (without quote) in the wildcard. To exclude *.exe" and all JUnit test cases, set filter type to "Exclude" and add two wildcard, one for "*.dll" and one for "*Test*"

                                                      To exclude a directory, set filter to "**/dir_to_exclude/**"

                                                      Note: (1) the wildcard is case insensitive, (2) all backslashes (\) will be replaced with slashes (/)

                                              • $class: 'FeatureBranchAwareMercurialSCM'
                                                • installation : String
                                                • source : String
                                                  Specify the repository to track. This can be URL or a local file path.
                                                • branch : String
                                                  Specify the branch name if you'd like to track a specific branch in a repository. Leave this field empty otherwise, to track the "default" branch.
                                                • modules : String
                                                  Reduce unnecessary builds by specifying a comma or space delimited list of "modules" within the repository. A module is a directory name within the repository that this project lives in. If this field is set, changes outside the specified modules will not trigger a build (even though the whole repository is checked out anyway due to the Mercurial limitation.)
                                                • subdir : String
                                                  If not empty, check out the Mercurial repository into this subdirectory of the job's workspace. For example: my/sources (use forward slashes). If changing this entry, you probably want to clean the workspace first.
                                                • browser
                                                    Nested Choice of Objects
                                                  • $class: 'FishEye'
                                                    • url : String
                                                      Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                  • $class: 'GoogleCode'
                                                    • url : String
                                                      Specify the root URL serving this repository (such as this).
                                                  • $class: 'HgWeb'
                                                    • url : String
                                                      Specify the root URL serving this repository (such as this).
                                                  • $class: 'Kallithea'
                                                    • url : String
                                                      Specify the root URL serving this repository (such as this).
                                                  • $class: 'KilnHG'
                                                    • url : String
                                                      Specify the root URL serving this repository (such as this).
                                                  • $class: 'RhodeCode'
                                                    • url : String
                                                      Specify the root URL serving this repository (such as this).
                                                  • $class: 'RhodeCodeLegacy'
                                                    • url : String
                                                      Specify the root URL serving this repository (such as this).
                                                  • $class: 'ScmManager'
                                                    • url : String
                                                      Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                • clean : boolean
                                                  When this option is checked, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                • branchPattern : String
                                              • $class: 'GeneXusServerSCM'
                                                Checks out (or updates) a Knowledge Base from a GeneXus Server.
                                                • gxInstallationId : String

                                                  GeneXus installation to use when creating (or updating) a local copy of a Knowledge Base from a GeneXus Server.

                                                  Select "(Custom)" if you want to specify a custom GeneXus path for this project (see Advanced Options).

                                                  The options that appear here are those you may configure in Jenkins "Global Tool Configuration" for GeneXus.

                                                • gxCustomPath : String

                                                  Custom path to a GeneXus installation to use when creating (or updating) a local copy of Knowledge Base from a GeneXus Server. This custom path is used when the "Custom" option is selected for the GeneXus Installation

                                                • msbuildCustomPath : String

                                                  Custom path to the MSBuild installation to use when creating (or updating) a local copy of Knowledge Base from a GeneXus Server.

                                                • serverURL : String
                                                  URL of the GeneXus Server from which to obtain (or update) a local copy of a Knowledge Base (eg: "https://sandbox.genexusserver.com/v16").
                                                • credentialsId : String

                                                  Credentials to use when authenticating to the GeneXus Server.

                                                  Select the credentials you want to use or click "Add" to enter a new user/password pair.

                                                • kbName : String
                                                  Name of the Knowledge Base in GeneXus Server from which to obtain (or update) a local copy.
                                                • kbVersion : String

                                                  Name of the Version that will be selected when creating a local copy of the Knowledge Base.

                                                  If you leave it blank the 'Trunk' version will be selected by default.

                                                • localKbPath : String

                                                  Path to the local Knowledge Base to use as working copy.

                                                  If you leave it blank the default ${WORKSPACE}\KBname will apply.

                                                • localKbVersion : String

                                                  Name of the Version in the local Knowledge Base that is linked to the Version in the server.

                                                  If you leave it blank the 'Trunk' version will be selected by default.

                                                • kbDbServerInstance : String
                                                  SQL Server used by GeneXus for the local Knowledge Base.
                                                • kbDbCredentialsId : String

                                                  Credentials to use when to connecting to SQL Server.

                                                  Select "none" for Windows Authentication.

                                                • kbDbName : String

                                                  Name of the SQL Server database used for the local Knowledge Base.

                                                  Leave it blank to use the default database name.

                                                • kbDbInSameFolder : boolean

                                                  Create the database files in the same folder as the Knowledge Base when checking out. Default is 'true'.

                                                  If kbDbInSameFolder is true or not set, then the database files will be created in the same folder as the Knowledge Base. If kbDbInSameFolder is false, then the database files will be created in the default folder configured for the SQL Server at kbDbServerInstance (optional).

                                              • scmGit
                                              • $class: 'HarvestSCM'
                                                • broker : String
                                                • passwordFile : String
                                                • userId : String
                                                • password : String
                                                • projectName : String
                                                • state : String
                                                • viewPath : String
                                                • clientPath : String
                                                • processName : String
                                                • recursiveSearch : String
                                                • useSynchronize : boolean
                                                • extraOptions : String
                                              • $class: 'IntegritySCM'
                                                Checks out source code from "Windchill RV&S for Configuration Management" repositories
                                                • serverConfig : String
                                                • configPath : String
                                                • configurationName : String
                                                • CPBasedMode : boolean (optional)
                                                • alternateWorkspace : String (optional)
                                                • browser (optional)
                                                    Nested Choice of Objects
                                                  • $class: 'IntegrityWebUI'
                                                    • url : String
                                                      Specify the URL of the PTC Windchill RV&S Configuration Management server.
                                                      For example: http://hostname:7001
                                                      This value is optional and is used as an override to the URL detected in the Windchill RV&S Change Log.
                                                • checkoutThreadPoolSize : int (optional)
                                                • checkoutThreadTimeout : int (optional)
                                                • checkpointBeforeBuild : boolean (optional)
                                                • checkpointLabel : String (optional)
                                                • cleanCopy : boolean (optional)
                                                • deleteNonMembers : boolean (optional)
                                                • excludeList : String (optional)
                                                • fetchChangedWorkspaceFiles : boolean (optional)
                                                • includeList : String (optional)
                                                • lineTerminator : String (optional)
                                                • localClient : boolean (optional)
                                                • password : String (optional)
                                                • restoreTimestamp : boolean (optional)
                                                • sandboxScope : String (optional)
                                                • skipAuthorInfo : boolean (optional)
                                                • userName : String (optional)
                                              • $class: 'IspwConfiguration'
                                                • connectionId : String
                                                • credentialsId : String
                                                • serverConfig : String
                                                • serverStream : String
                                                • serverApplication : String
                                                • serverSubAppl : String
                                                • serverLevel : String
                                                • levelOption : String
                                                • componentType : String
                                                • folderName : String
                                                • ispwDownloadAll : boolean
                                                • targetFolder : String
                                                • ispwDownloadIncl : boolean
                                                • ispwDownloadWithCompileOnly : boolean
                                              • $class: 'IspwContainerConfiguration'
                                                • connectionId : String
                                                • credentialsId : String
                                                • serverConfig : String
                                                • containerName : String
                                                • containerType : String
                                                • serverLevel : String
                                                • componentType : String
                                                • ispwDownloadAll : boolean
                                                • targetFolder : String
                                                • ispwDownloadIncl : boolean
                                              • $class: 'MercurialSCM'
                                              • $class: 'MergebotScm'
                                                • cleanup
                                                  • Values: MINIMAL, STANDARD, FULL, DELETE
                                                • workingMode
                                                  • Values: NONE, UP, LDAP
                                                • credentialsId : String
                                                • specAttributeName : String
                                              • $class: 'MultiSCM'
                                              • none
                                                • $class: 'OpenShiftImageStreams'
                                                  • imageStreamName : String
                                                    The name of the ImageStream is what shows up in the NAME column if you dump all the ImageStream's with the `oc get is` command invocation.
                                                  • tag : String
                                                    The specific image tag within the ImageStream to monitor.
                                                  • apiURL : String
                                                  • namespace : String
                                                  • authToken : String
                                                  • verbose : String
                                                • $class: 'PdsConfiguration'
                                                  • connectionId : String
                                                  • filterPattern : String
                                                  • fileExtension : String
                                                  • credentialsId : String
                                                  • targetFolder : String
                                                • perforce
                                                  • credential : String
                                                    Perforce Credentials

                                                    Select the appropriate credential for the Perforce connection. Perforce Credentials are defined in the Jenkins Credentials plugin here.

                                                    There are two types:

                                                    • 'Perforce Password Credential' for standard username/password authentication
                                                    • 'Perforce Ticket Credential' for ticket based authentication.
                                                  • workspace
                                                    Workspace Behaviour

                                                    Select the appropriate Perforce workspace behaviour from the list. Not all modes will suit all Jenkins Job build types.

                                                    There are five types:

                                                      Manual
                                                      Manually define the Workspace view and sync options. Existing workspace will by updated or a new workspace created.
                                                      Spec File
                                                      Use a pre-defined Workspace Spec file versioned in Perforce.
                                                      Static
                                                      Use a pre-defined Workspace; must already exist and have a valid view.
                                                      Streams
                                                      Auto create/update a Streams workspace with a view determined by the chosen stream.
                                                      Template
                                                      Auto create/update a normal workspace with a view determined by the template workspace.
                                                      Nested Choice of Objects
                                                    • manualSpec
                                                      • charset : String
                                                        P4CHARSET

                                                        The character set used by Jenkins when syncing files from the Perforce server. This should be set to 'none' unless connected to a Unicode enabled Perforce server.

                                                      • pinHost : boolean
                                                      • name : String
                                                        Workspace name

                                                        Specify the name of the Perforce workspace to be used as the Jenkins build workspace. If the workspace does not yet exist, the configuration will be saved in Jenkins; the workspace is created only when it is to be used. If the workspace exists and you are connected to a Perforce server the auto-text fill should list suitable workspaces; updates are only applied when the workspace is used.

                                                      • spec
                                                          Nested Object
                                                        • allwrite : boolean
                                                        • clobber : boolean
                                                        • compress : boolean
                                                        • locked : boolean
                                                        • modtime : boolean
                                                        • rmdir : boolean
                                                        • streamName : String
                                                        • line : String
                                                          Line Endings

                                                          Set line-ending character(s) for client text files.

                                                          • UNIX

                                                            linefeed: UNIX style.

                                                          • MAC

                                                            carriage return: Macintosh style. (obsolete)

                                                          • WIN

                                                            carriage return-linefeed: Windows style.

                                                          • SHARE

                                                            hybrid: writes UNIX style but reads UNIX, Mac or Windows style.

                                                        • view : String
                                                          View

                                                          Lines to map depot files into the client workspace.

                                                          The variable ${P4_CLIENT} will expand to the client name, for example, a simple mapping:

                                                          //depot/... //${P4_CLIENT}/...

                                                          Maps files in the depot to files in your client workspace. Defines the files that you want in your client workspace and specifies where you want them to reside. The default view maps all depot files onto the client. See 'p4 help views' for view syntax. A new view takes effect on the next 'p4 sync'.

                                                          To support migration from the old Perforce plugin, a View Mapping can be inserted from a file in Perforce. Add the depot path to the "View Mappings" field Prefix "@" (this only applies to the "Manual" Workspace behaviour).

                                                        • changeView : String
                                                        • type : String
                                                          Type

                                                          Type of client: writeable/readonly/partitioned/graph

                                                          By default all clients are 'writeable', certain clients are short lived and perform long sync and build cycles. Over time these build clients can fragment the 'db.have' table which is used to track what files a client has synced. Setting a type of 'readonly' gives the client its own personal 'db.have' database table. A 'readonly' client cannot 'edit' or 'submit' files, however for build automation this is not usually a requirement and the performance tradeoff is worth considering if your build automation is causing issues with the 'db.have' table. This option requires that an administrator has first configured the 'client.readonly.dir' setting. If it is necessary to submit changes as part of your build, you may specify a 'partitioned' client: like a 'reaonly' client, this type also has a separate 'db.have' table under the 'client.readonly.dir' directory, but allows journalled 'edit' and 'submit' of files.

                                                        • serverID : String
                                                        • backup : boolean
                                                          Backup

                                                          Client's participation in backup enable/disable. If not specified backup of a writable client defaults to enabled.

                                                        • streamAtChange : String (optional)
                                                          Stream at change

                                                          When specified, the client view is generated from the stream specification version at or before the change number.

                                                      • cleanup : boolean
                                                      • syncID : String (optional)
                                                    • specFileSpec
                                                      • charset : String
                                                        P4CHARSET

                                                        The character set used by Jenkins when syncing files from the Perforce server. This should be set to 'none' unless connected to a Unicode enabled Perforce server.

                                                      • pinHost : boolean
                                                      • name : String
                                                        An existing workspace

                                                        Specify the name of the Perforce workspace to be used as the Jenkins build workspace. If the workspace does not yet exist, the configuration will be saved in Jenkins; the workspace is created only when it is to be used. If the workspace exists and you are connected to a Perforce server the auto-text fill should list suitable workspaces; updates are only applied when the workspace is used.

                                                      • specPath : String
                                                      • syncID : String (optional)
                                                    • staticSpec
                                                      • charset : String
                                                        P4CHARSET

                                                        The character set used by Jenkins when syncing files from the Perforce server. This should be set to 'none' unless connected to a Unicode enabled Perforce server.

                                                      • pinHost : boolean
                                                      • name : String
                                                        An existing workspace

                                                        Specify the name of an existing workspace in Perforce to be used as the Jenkins build workspace. If connected to a Perforce server the auto-text fill should list suitable workspaces

                                                      • syncID : String (optional)
                                                    • streamSpec
                                                      • charset : String
                                                        P4CHARSET

                                                        The character set used by Jenkins when syncing files from the Perforce server. This should be set to 'none' unless connected to a Unicode enabled Perforce server.

                                                      • pinHost : boolean
                                                      • streamName : String
                                                        Stream codeline

                                                        Specify the full Perforce depot path for the given stream. If connected to a Perforce server the auto-text fill should list possible streams.

                                                        For example: //stream-depot/main-stream
                                                      • format : String
                                                        Workspace name formatter

                                                        Jenklin slave nodes must each use a unique Perforce workspace. The format string configures the workspace name by substituting the specified variables: (at least one variable must be used)

                                                        Variables can be taken from the Jenkins Environment or Parameterized builds

                                                      • streamAtChange : String (optional)
                                                        Stream at change

                                                        When specified, the client view is generated from the stream specification version at or before the change number.

                                                      • syncID : String (optional)
                                                    • templateSpec
                                                      • charset : String
                                                        P4CHARSET

                                                        The character set used by Jenkins when syncing files from the Perforce server. This should be set to 'none' unless connected to a Unicode enabled Perforce server.

                                                      • pinHost : boolean
                                                      • templateName : String
                                                        Templace workspace

                                                        Specify the name of an existing workspace in Perforce used to create or update a Jenkins build workspace. If connected to a Perforce server the auto-text fill should list suitable workspaces

                                                      • format : String
                                                        Workspace name formatter

                                                        Jenklin slave nodes must each use a unique Perforce workspace. The format string configures the workspace name by substituting the specified variables: (at least one variable must be used)

                                                        Variables can be taken from the Jenkins Environment or Parameterized builds

                                                      • syncID : String (optional)
                                                  • filter
                                                      Array / List of Nested Choice of Objects
                                                    • latest
                                                      • latestChange : boolean
                                                    • latestWithPin
                                                      • latestWithPin : boolean
                                                        Polling latest change with pin

                                                        When enabled, in case of a pinned checkout, polling ignores the pin or the label specified in the checkout step and polls till the latest change.

                                                    • pathFilter
                                                      • path : String
                                                        Depot path filter

                                                        Changes can be filtered to not trigger a build; if all the files within a change match the specified path, the build is filtered.

                                                        For example, with a Filter of " //depot/main/tests ":

                                                        Case A (change will be filtered):

                                                        Files:

                                                        • //depot/main/tests/index.xml
                                                        • //depot/main/tests/001/test.xml
                                                        • //depot/main/tests/002/test.xml

                                                        Case B (change will not be filtered, as build.xml is outside of the filter):

                                                        Files:

                                                        • //depot/main/src/build.xml
                                                        • //depot/main/tests/004/test.xml
                                                        • //depot/main/tests/005/test.xml

                                                        This is not Perforce syntax. Use of ... and * patterns are not supported. Only paths to directories are supported.

                                                    • viewPattern
                                                      • patternText : String
                                                        Java Pattern filter

                                                        Changes can be filtered to not trigger a build; if none of the files within a change match a Java pattern (regular expression) listed, the build is filtered.

                                                        For example, with the following regular expressions:
                                                        //depot/main/tests.*
                                                        //depot/main/src/.*\.cpp
                                                        //depot/main/build/.*(?:\.rb|\.py|\.bat|Jenkinsfile)
                                                        //depot/main/lib/(?!Lib1|Lib2).*

                                                        Case A (change will not be filtered, as these files match our first pattern on "tests"):

                                                        Files:

                                                        • //depot/main/tests/CONTRIUBTING.md
                                                        • //depot/main/tests/001/index.xml

                                                        Case B (Be careful with incomplete file paths! Change will NOT be filtered,
                                                        as this file matches a pattern which was likely intended as describing a "tests/" directory.)

                                                        Files:

                                                        • //depot/main/tests.doc

                                                        Case C (change will NOT be filtered, as all files match our fourth pattern looking for script files in 'build/'):

                                                        Files:

                                                        • //depot/main/build/rbs/deploy_server.rb
                                                        • //depot/main/build/deploy/deploy.bat
                                                        • //depot/main/build/Jenkinsfile

                                                        Case D (change will be filtered, as no file matches our second pattern for ".cpp" files under "main/src"):

                                                        Files:

                                                        • //depot/main/src/howto.doc
                                                        • //depot/main/src/oldmain.c
                                                        • //depot/main/src/art/splash.bmp
                                                        • //depot/main/src/bt/funnelcake.php

                                                        Case E (change will be filtered. Lib1 is included in a negative lookahead, and thus is excluded.)

                                                        Files:

                                                        • //depot/main/lib/Lib1/build.xml
                                                      • caseSensitive : boolean
                                                    • incremental
                                                      • perChange : boolean
                                                        Polling per change

                                                        When enabled, only the one, oldest changelist returned by polling is built.

                                                        If P4_INCREMENTAL environment variable (or build parameter) is set to "false", polling per change is ignored and all changelists are built.

                                                    • userFilter
                                                      • user : String
                                                        User name filter

                                                        Changes can be filtered to not trigger a build; if the owner of a change matches the specified name, the build is filtered.

                                                    • viewFilter
                                                      • viewMask : String
                                                        View Mask filter

                                                        Changes can be filtered to not trigger a build; if none of the files within a change are contained in the view mask, the build is filtered.

                                                        For example, with a View Mask Filter of:
                                                        //depot/main/tests
                                                        -//depot/main/tests/001

                                                        Case A (change will not be filtered, as index.xml is in the view mask):

                                                        Files:

                                                        • //depot/main/tests/index.xml
                                                        • //depot/main/tests/001/test.xml

                                                        Case B (change will not be filtered, as index.xml is in the view mask):

                                                        Files:

                                                        • //depot/main/test/index.xml
                                                        • //depot/main/src/build.xml

                                                        Case C (change will be filtered, as no file is in the view mask):

                                                        Files:

                                                        • //depot/main/src/build.xml

                                                        Case D (change will be filtered, as no file is in the view mask):

                                                        Files:

                                                        • //depot/main/src/build.xml
                                                        • //depot/main/tests/001/test.xml
                                                  • populate
                                                    Populate Options

                                                    Perforce will populate the workspace with the file revisions needed for the build. The different options effect the way the workspace is cleaned and the file revisions are updated.

                                                    There are three options:

                                                      Automatic Cleanup and Sync
                                                      Efficient cleaning and syncing of file revisions. Extra (non versioned files) are removed, missing and modified files re-added.
                                                      Best for clean builds.
                                                      Flush Workspace
                                                      No files Sync or cleanup attempted, but the Workspace's have list is updated.
                                                      Effective command 'p4 sync -k'.
                                                      Force Clean and Sync
                                                      Will remove all files from under the workspace root, then force sync the required files. Inefficient and NOT RECOMENDED.
                                                      Graph Force Clean and Sync/dt>
                                                      For Graph and Hybrid only, will remove all files from under the workspace root, then force sync the required files.
                                                      Preview Check Only
                                                      No files Sync or cleanup attempted; the Workspace's have list is not updated.
                                                      Effective command 'p4 sync -n'.
                                                      Sync Only
                                                      No cleanup attempted; the sync will update all files (as CLOBBER is set) to the required set of revisions.
                                                      Best for incremental builds.
                                                      Nested Choice of Objects
                                                    • autoClean
                                                      • replace : boolean
                                                        REPLACE missing/modified files

                                                        Perforce will check out and overwrite any depot files which are either missing from workspace, or have been modified locally.

                                                      • delete : boolean
                                                        DELETE generated files

                                                        Perforce will delete any local files that are not in the depot.

                                                      • tidy : boolean
                                                      • modtime : boolean
                                                      • quiet : boolean
                                                        Suppressing info messages

                                                        Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                      • pin : String
                                                        Pinning a build at Perforce Label

                                                        When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                        Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                      • parallel
                                                          Nested Object
                                                        • enable : boolean
                                                        • path : String
                                                        • threads : String
                                                        • minfiles : String
                                                        • minbytes : String
                                                    • previewOnly
                                                      • quiet : boolean
                                                        Suppressing info messages

                                                        Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                      • pin : String
                                                    • flushOnly
                                                      • quiet : boolean
                                                      • pin : String
                                                        Pinning a build at Perforce Label

                                                        When a build is triggered by Polling, Build Now or an external Action, the workspace will flush only to the specified label or changelist number. Any other specified change or label will be ignored.

                                                        Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                    • forceClean
                                                      • have : boolean
                                                      • quiet : boolean
                                                        Suppressing info messages

                                                        Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                      • pin : String
                                                        Pinning a build at Perforce Label

                                                        When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                        Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                      • parallel
                                                          Nested Object
                                                        • enable : boolean
                                                        • path : String
                                                        • threads : String
                                                        • minfiles : String
                                                        • minbytes : String
                                                    • graphClean
                                                      • quiet : boolean
                                                        Suppressing info messages

                                                        Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                      • pin : String
                                                        Pinning a build at Perforce Label

                                                        When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                        Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                      • parallel
                                                          Nested Object
                                                        • enable : boolean
                                                        • path : String
                                                        • threads : String
                                                        • minfiles : String
                                                        • minbytes : String
                                                    • syncOnly
                                                      • revert : boolean
                                                      • have : boolean
                                                      • force : boolean
                                                      • modtime : boolean
                                                      • quiet : boolean
                                                        Suppressing info messages

                                                        Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                      • pin : String
                                                        Pinning a build at Perforce Label

                                                        When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                        Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                      • parallel
                                                          Nested Object
                                                        • enable : boolean
                                                        • path : String
                                                        • threads : String
                                                        • minfiles : String
                                                        • minbytes : String
                                                  • browser
                                                      Nested Choice of Objects
                                                    • fishEye
                                                      • url : String
                                                      • rootModule : String
                                                    • openGrok
                                                      • url : String
                                                      • depotPath : String
                                                      • projectName : String
                                                    • p4Web
                                                      • url : String
                                                    • swarm
                                                      • url : String
                                                • $class: 'PlasticSCM'
                                                  • selector : String
                                                  • cleanup
                                                    • Values: MINIMAL, STANDARD, FULL, DELETE
                                                  • workingMode
                                                    • Values: NONE, UP, LDAP
                                                  • credentialsId : String
                                                  • useMultipleWorkspaces : boolean
                                                  • additionalWorkspaces
                                                      Array / List of Nested Object
                                                    • selector : String
                                                    • cleanup
                                                      • Values: MINIMAL, STANDARD, FULL, DELETE
                                                    • directory : String
                                                  • pollOnController : boolean
                                                  • directory : String
                                                • $class: 'ProxySCM'
                                                  • projectName : String
                                                • $class: 'PvcsScm'
                                                  • projectRoot : String
                                                  • archiveRoot : String
                                                  • changeLogPrefixFudge : String
                                                  • moduleDir : String
                                                  • loginId : String
                                                  • pvcsWorkspace : String
                                                  • promotionGroup : String
                                                  • versionLabel : String
                                                  • cleanCopy : boolean
                                                • $class: 'RTCScm'
                                                • $class: 'SCLMSCM'
                                                  • server : String
                                                  • port : int
                                                  • credentialsId : String
                                                  • JESINTERFACELEVEL1 : boolean
                                                  • FTPActiveMode : boolean
                                                  • project : String
                                                  • alternate : String
                                                  • group : String
                                                  • types : String
                                                  • custJobStep : boolean
                                                  • JobStep : String
                                                  • custJobHeader : boolean
                                                  • JobHeader : String
                                                • $class: 'ShellScriptSCM'
                                                  • checkoutShell : String
                                                  • pollingShell : String
                                                  • useCheckoutForPolling : boolean
                                                • $class: 'SimpleClearCaseSCM'
                                                  • loadRules : String
                                                    Specify the paths to the source code inside of ClearCase VOBS. one Path for each line. For instance:

                                                    /vobs/structure/package/product/subproduct
                                                    /vobs/structure/package/product/anothersubproduct.

                                                  • viewname : String
                                                    The viewname which has a configured config spec. This is external to the plugin as the way the config spec can be configured in many different ways. From updating the config spec dynamically with fixed intervals to having a constant one throughout a full project life time.
                                                  • branch : String
                                                    Specify which branch to follow. Not mandatory. If not set then all branches will be followed, i.e you will get notifications about changes in branches which your config specification isn't related to. Example value: main, dev etc.
                                                  • filter : boolean
                                                    Filters out mkbranch and rmbranch messages in lshistory. These changes isn't relevant if you are tracking source files in a specific branch.
                                                • $class: 'StoreSCM'
                                                  • scriptName : String
                                                  • repositoryName : String
                                                    Specify the name of the Store repository to be checked. It is assumed that the Smalltalk image being run by the "script" property will contain any necessary repository definitions.
                                                  • pundles
                                                    List the names of the top-level pundles (bundles and/or packages) to check for changes. All listed pundles and their recursive prerequisites will be checked.
                                                      Array / List of Nested Object
                                                    • pundleType
                                                      • Values: PACKAGE, BUNDLE
                                                    • name : String
                                                  • versionRegex : String
                                                    Specify a Regex11-style regular expression that specifies which pundle versions to consider when checking for changes. Examples:
                                                    • .+ (the default) will match any version string
                                                    • \d+ will match any integer version number
                                                    • (7.9\s*-\s*)?\d+ will match any integer version number with an optional "7.9 - " prefix
                                                  • minimumBlessingLevel : String
                                                    Choose the minimum Store blessing level that should be considered. Pundle versions with a lower blessing level will be ignored.
                                                  • generateParcelBuilderInputFile : boolean
                                                    Check this if Jenkins should generate an input file for ParcelBuilder or a similar tool. A ParcelBuilder input file specifies the type, name, and version of all of the Pundles that are part of the current build.
                                                  • parcelBuilderInputFilename : String
                                                    The name of the file, relative to the Jenkins workspace directory, where the input file for ParcelBuilder will be written.
                                                • $class: 'SubversionSCM'
                                                • $class: 'SurroundSCM'
                                                  • server : String
                                                  • serverPort : String
                                                  • branch : String
                                                  • repository : String
                                                  • credentialsId : String
                                                  • rsaKey (optional)
                                                      Nested Object
                                                    • rsaKeyFileId : String (optional)
                                                    • rsaKeyFilePath : String (optional)
                                                    • rsaKeyType (optional)
                                                      • Values: NoKey, Path, ID
                                                    • rsaKeyValue : String (optional)
                                                  • rsaKeyFileId : String (optional)
                                                  • rsaKeyFilePath : String (optional)
                                                    Enter the full path to the RSA key file for the Surround SCM connection. Example: C:\SurroundRSAKeyFile.xml
                                                  • rsaKeyPath : String (optional)
                                                • $class: 'SynergySCM'
                                                  • project : String
                                                  • database : String
                                                  • release : String
                                                  • purpose : String
                                                  • username : String
                                                  • password : String
                                                  • engine : String
                                                  • oldProject : String
                                                  • baseline : String
                                                  • oldBaseline : String
                                                  • ccmHome : String
                                                  • remoteClient : boolean
                                                  • detectConflict : boolean
                                                  • replaceSubprojects : boolean
                                                  • checkForUpdateWarnings : boolean
                                                  • leaveSessionOpen : boolean
                                                  • maintainWorkarea : boolean
                                                  • checkTaskModifiedObjects : boolean
                                                • $class: 'VaultSCM'
                                                  • serverName : String
                                                    Specify the hostname or IP address of the vault server.
                                                  • path : String
                                                  • userName : String
                                                  • password : String
                                                  • repositoryName : String
                                                  • vaultName : String
                                                  • sslEnabled : boolean
                                                  • useNonWorkingFolder : boolean
                                                  • merge : String
                                                  • fileTime : String
                                                  • makeWritableEnabled : boolean
                                                  • verboseEnabled : boolean
                                                • $class: 'hudson.plugins.gradle_repo.RepoScm'
                                                  • repositoryUrl : String
                                                  • branch : String
                                                • $class: 'hudson.plugins.repo.RepoScm'
                                              • clone : boolean (optional)
                                                If checked, every build performs a fresh clone of the SCM rather than locking and updating a common copy. No changelog will be computed. For Git, you are advised to add Advanced clone behaviors and then check Shallow clone and Honor refspec on initial clone and uncheck Fetch tags to make the clone much faster. You may still enable Cache fetched versions on controller for quick retrieval if you prefer.
                                              • libraryPath : String (optional)
                                                A relative path from the root of the SCM to the root of the library. Leave this field blank if the root of the library is the root of the SCM. Note that ".." is not permitted as a path component to avoid security issues.
                                            • modernSCM
                                              • scm
                                                  Nested Choice of Objects
                                                • $class: 'BacklogPullRequestSCMSource'
                                                • multiBranch
                                                • dagshubScmSource
                                                • gerrit
                                                  • remote : String
                                                    Specify the URL of this remote repository. This uses the same syntax as your git clone command.
                                                  • browser (optional)
                                                      Nested Choice of Objects
                                                    • assembla
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                    • $class: 'BacklogGitRepositoryBrowser'
                                                      • repoName : String
                                                      • repoUrl : String
                                                    • bitbucketServer
                                                      • repoUrl : String
                                                        Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                    • bitbucket
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                    • cgit
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                    • fisheye
                                                      • repoUrl : String
                                                        Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                    • gitblit
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository.
                                                      • projectName : String
                                                        Specify the name of the project in GitBlit.
                                                    • $class: 'GitBucketBrowser'
                                                      • url : String
                                                    • gitLab
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                      • version : String (optional)
                                                        Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                    • gitLabBrowser
                                                      Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                      • projectUrl : String
                                                        Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                    • gitList
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                    • gitWeb
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                    • $class: 'GiteaBrowser'
                                                      • repoUrl : String
                                                        Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                    • github
                                                      • repoUrl : String
                                                        Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                    • gitiles
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                    • $class: 'GitoriousWeb'
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                    • gogs
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                    • kiln
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                    • phabricator
                                                      • repoUrl : String
                                                        Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                      • repo : String
                                                        Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                    • redmine
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                    • rhodeCode
                                                      • repoUrl : String
                                                        Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                    • $class: 'ScmManagerGitRepositoryBrowser'
                                                      • repoUrl : String
                                                        Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                    • $class: 'Stash'
                                                      • repoUrl : String
                                                        Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                    • teamFoundation
                                                      • repoUrl : String
                                                        Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                        If TFS is also used as the repository server, this can usually be left blank.

                                                    • $class: 'TracGitRepositoryBrowser'
                                                      • $class: 'TuleapBrowser'
                                                        Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                        • repositoryUrl : String
                                                          The URL is the web URL of the Tuleap Git repository.
                                                      • viewgit
                                                        • repoUrl : String
                                                          Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                        • projectName : String
                                                          Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                    • credentialsId : String (optional)
                                                      Credentials used to scan branches and check out sources.
                                                    • extensions (optional)
                                                        Array / List of Nested Choice of Objects
                                                      • authorInChangelog
                                                        The default behavior is to use the Git commit's "Committer" value in Jenkins' build changesets. If this option is selected, the Git commit's "Author" value would be used instead.
                                                        • $class: 'BuildChooserSetting'
                                                          When you are interested in using a job to build multiple heads (most typically multiple branches), you can choose how Jenkins choose what branches to build in what order.

                                                          This extension point in Jenkins is used by many other plugins to control the job to build specific commits. When you activate those plugins, you may see them installing a custom strategy here.

                                                          • buildChooser
                                                              Nested Choice of Objects
                                                            • $class: 'AlternativeBuildChooser'
                                                              • $class: 'AncestryBuildChooser'
                                                                • maximumAgeInDays : int
                                                                • ancestorCommitSha1 : String
                                                              • $class: 'DefaultBuildChooser'
                                                                • $class: 'DeflakeGitBuildChooser'
                                                                  • $class: 'GerritTriggerBuildChooser'
                                                                    • $class: 'InverseBuildChooser'
                                                                  • buildSingleRevisionOnly
                                                                    Disable scheduling for multiple candidate revisions.
                                                                    If we have 3 branches:
                                                                    ----A--.---.--- B
                                                                             \-----C
                                                                    jenkins would try to build (B) and (C).
                                                                    This behaviour disables this and only builds one of them.
                                                                    It is helpful to reduce the load of the Jenkins infrastructure when the SCM system like Bitbucket or GitHub should decide what commits to build.
                                                                    • changelogToBranch
                                                                      This method calculates the changelog against the specified branch.
                                                                      • options
                                                                          Nested Object
                                                                        • compareRemote : String
                                                                          Name of the repository, such as origin, that contains the branch you specify below.
                                                                        • compareTarget : String
                                                                          The name of the branch within the named repository to compare against.
                                                                    • checkoutOption
                                                                      • timeout : int
                                                                        Specify a timeout (in minutes) for checkout.
                                                                        This option overrides the default timeout of 10 minutes.
                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                    • cleanBeforeCheckout
                                                                      Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                    • cleanAfterCheckout
                                                                      Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                    • cloneOption
                                                                      • shallow : boolean
                                                                        Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                      • noTags : boolean
                                                                        Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                      • reference : String
                                                                        Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                        This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                      • timeout : int
                                                                        Specify a timeout (in minutes) for clone and fetch operations.
                                                                        This option overrides the default timeout of 10 minutes.
                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                      • depth : int (optional)
                                                                        Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                      • honorRefspec : boolean (optional)
                                                                        Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                    • $class: 'CodeCommitURLHelper'
                                                                      • credentialId : String

                                                                        OPTIONAL: Select the credentials to use.
                                                                        If not specified, defaults to the DefaultAWSCredentialsProviderChain behaviour - *FROM THE JENKINS INSTANCE*

                                                                        In the latter case, usage of IAM Role Profiles seems not to work, thus relying on environment variables / system properties or the ~/.aws/credentials file, thus not recommended.

                                                                      • repositoryName : String
                                                                    • $class: 'DisableRemotePoll'
                                                                      Git plugin uses git ls-remote polling mechanism by default when configured with a single branch (no wildcards!). This compare the latest built commit SHA with the remote branch without cloning a local copy of the repo.

                                                                      If you don't want to / can't use this.

                                                                      If this option is selected, polling will require a workspace and might trigger unwanted builds (see JENKINS-10131).
                                                                      • $class: 'ExcludeFromChangeSet'
                                                                        • $class: 'ExcludeFromPoll'
                                                                          • lfs
                                                                            Enable git large file support for the workspace by pulling large files after the checkout completes. Requires that the controller and each agent performing an LFS checkout have installed `git lfs`.
                                                                            • $class: 'GitSCMChecksExtension'
                                                                              • verboseConsoleLog : boolean (optional)
                                                                                If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                            • $class: 'GitSCMStatusChecksExtension'
                                                                              • name : String (optional)
                                                                              • skip : boolean (optional)
                                                                              • skipProgressUpdates : boolean (optional)
                                                                              • suppressLogs : boolean (optional)
                                                                              • unstableBuildNeutral : boolean (optional)
                                                                            • $class: 'GitTagMessageExtension'
                                                                              If the revision checked out has a git tag associated with it, the tag name will be exported during the build as GIT_TAG_NAME.
                                                                              If a message was specified when creating the tag, then that message will be exported during the build as the GIT_TAG_MESSAGE environment variable.
                                                                              If no tag message was specified, the commit message will be used.
                                                                              If you ticked the Use most recent tag option, and the revision checked out has no git tag associated with it, the parent commits will be searched for a git tag, and the rules stated above will apply to the first parent commit with a git tag.

                                                                              If the revision has more than one tag associated with it, only the most recent tag will be taken into account, unless the refspec contains "refs/tags/" — i.e. builds are only triggered when certain tag names or patterns are matched — in which case the exact tag name that triggered the build will be used, even if it's not the most recent tag for this commit.
                                                                              For this reason, if you're not using a tag-specific refspec but you are using the "Create a tag for every build" behaviour, you should make sure that the build-tagging behaviour is configured to run after this "export git tag message" behaviour.

                                                                              Tag and commit messages which span multiple lines are no problem, though only the first 10000 lines of a tag's message will be exported.
                                                                              • useMostRecentTag : boolean (optional)
                                                                            • $class: 'IgnoreNotifyCommit'
                                                                              If checked, this repository will be ignored when the notifyCommit-URL is accessed regardless of if the repository matches or not.
                                                                              • localBranch
                                                                                If given, checkout the revision to build as HEAD on this branch.

                                                                                If selected, and its value is an empty string or "**", then the branch name is computed from the remote branch without the origin. In that case, a remote branch origin/master will be checked out to a local branch named master, and a remote branch origin/develop/new-feature will be checked out to a local branch named develop/newfeature.

                                                                                Please note that this has not been tested with submodules.

                                                                                • localBranch : String
                                                                              • $class: 'MessageExclusion'
                                                                                • excludedMessage : String
                                                                                  If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed with message matched to Pattern when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.

                                                                                  Exclusion uses Pattern matching

                                                                                  .*\[maven-release-plugin\].*
                                                                                  The example above illustrates that if only revisions with "[maven-release-plugin]" message in first comment line have been committed to the SCM a build will not occur.

                                                                                  You can create more complex patterns using embedded flag expressions.
                                                                                  (?s).*FOO.*
                                                                                  This example will search FOO message in all comment lines.
                                                                              • $class: 'PathRestriction'
                                                                                If set, and Jenkins is set to poll for changes, Jenkins will pay attention to included and/or excluded files and/or folders when determining if a build needs to be triggered.

                                                                                Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.
                                                                                • includedRegions : String
                                                                                  Each inclusion uses java regular expression pattern matching, and must be separated by a new line. An empty list implies that everything is included.

                                                                                      myapp/src/main/web/.*\.html
                                                                                      myapp/src/main/web/.*\.jpeg
                                                                                      myapp/src/main/web/.*\.gif
                                                                                    
                                                                                  The example above illustrates that a build will only occur, if html/jpeg/gif files have been committed to the SCM. Exclusions take precedence over inclusions, if there is an overlap between included and excluded regions.
                                                                                • excludedRegions : String
                                                                                  Each exclusion uses java regular expression pattern matching, and must be separated by a new line.

                                                                                      myapp/src/main/web/.*\.html
                                                                                      myapp/src/main/web/.*\.jpeg
                                                                                      myapp/src/main/web/.*\.gif
                                                                                    
                                                                                  The example above illustrates that if only html/jpeg/gif files have been committed to the SCM a build will not occur.
                                                                              • perBuildTag
                                                                                Create a tag in the workspace for every build to unambiguously mark the commit that was built. You can combine this with Git publisher to push the tags to the remote repository.
                                                                                • $class: 'PreBuildMerge'
                                                                                  These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                  • options
                                                                                      Nested Object
                                                                                    • mergeTarget : String
                                                                                      The name of the branch within the named repository to merge to, such as master.
                                                                                    • fastForwardMode (optional)
                                                                                      Merge fast-forward mode selection.
                                                                                      The default, --ff, gracefully falls back to a merge commit when required.
                                                                                      For more information, see the Git Merge Documentation
                                                                                      • Values: FF, FF_ONLY, NO_FF
                                                                                    • mergeRemote : String (optional)
                                                                                      Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                    • mergeStrategy (optional)
                                                                                      Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                      • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                • pretestedIntegration
                                                                                  • gitIntegrationStrategy
                                                                                      Nested Choice of Objects
                                                                                    • accumulated

                                                                                      Accumulated Commit Strategy

                                                                                      This strategy merges your commits with the --no-ff switch
                                                                                      • shortCommitMessage : boolean (optional)
                                                                                    • ffonly

                                                                                      Fast Forward only (--ff-only) Strategy

                                                                                      This strategy fast-forward only using the --ff-only switch - or fails
                                                                                      • shortCommitMessage : boolean (optional)
                                                                                    • squash

                                                                                      Squashed Commit Strategy

                                                                                      This strategy squashes all your commit on a given branch with the --squash option
                                                                                    • integrationBranch : String

                                                                                      What to specify

                                                                                      The branch name must match your integration branch name. No trailing slash.

                                                                                      Merge is performed the following way

                                                                                      Squash commit
                                                                                                  git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                  git merge --squash <Branch matched by git>
                                                                                                  git commit -C <Branch matched by git>
                                                                                      Accumulated commit
                                                                                                  git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                  git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                      When changes are pushed to the integration branch?

                                                                                      Changes are only ever pushed when the build results is SUCCESS

                                                                                                  git push <Repository name> <Branch name>
                                                                                    • repoName : String

                                                                                      What to specify

                                                                                      The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                      No trailing slash on repository name.

                                                                                      Remember to specify this when working with NAMED repositories in Git

                                                                                  • pruneStaleBranch
                                                                                    Run "git remote prune" for each remote, to prune obsolete local branches.
                                                                                    • pruneTags
                                                                                      • pruneTags : boolean
                                                                                    • $class: 'RelativeTargetDirectory'
                                                                                      • relativeTargetDir : String
                                                                                        Specify a local directory (relative to the workspace root) where the Git repository will be checked out. If left empty, the workspace root itself will be used.

                                                                                        This extension should not be used in Jenkins Pipeline (either declarative or scripted). Jenkins Pipeline already provides standard techniques for checkout to a subdirectory. Use ws and dir in Jenkins Pipeline rather than this extension.

                                                                                    • $class: 'ScmName'

                                                                                      Unique name for this SCM. Needed when using Git within the Multi SCM plugin.

                                                                                      • name : String
                                                                                    • $class: 'SparseCheckoutPaths'

                                                                                      Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                      • sparseCheckoutPaths
                                                                                          Array / List of Nested Object
                                                                                        • path : String
                                                                                    • submodule
                                                                                      • depth : int (optional)
                                                                                        Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                      • disableSubmodules : boolean (optional)
                                                                                        By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                      • parentCredentials : boolean (optional)
                                                                                        Use credentials from the default remote of the parent project.
                                                                                      • recursiveSubmodules : boolean (optional)
                                                                                        Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                      • reference : String (optional)
                                                                                        Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                        This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                        To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                          git init --bare
                                                                                          git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                          git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                          git fetch --all
                                                                                          
                                                                                      • shallow : boolean (optional)
                                                                                        Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                      • threads : int (optional)
                                                                                        Specify the number of threads that will be used to update submodules.
                                                                                        If unspecified, the command line git default thread count is used.
                                                                                      • timeout : int (optional)
                                                                                        Specify a timeout (in minutes) for submodules operations.
                                                                                        This option overrides the default timeout of 10 minutes.
                                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                      • trackingSubmodules : boolean (optional)
                                                                                        Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                    • $class: 'UserExclusion'
                                                                                      • excludedUsers : String
                                                                                        If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed by users in this list when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.

                                                                                        Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.

                                                                                        Each exclusion uses exact string comparison and must be separated by a new line. User names are only excluded if they exactly match one of the names in this list.

                                                                                        auto_build_user
                                                                                        The example above illustrates that if only revisions by "auto_build_user" have been committed to the SCM a build will not occur.
                                                                                    • $class: 'UserIdentity'
                                                                                      • name : String

                                                                                        If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                      • email : String

                                                                                        If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                    • $class: 'WipeWorkspace'
                                                                                      Delete the contents of the workspace before building, ensuring a fully fresh workspace.
                                                                                    • gitTool : String (optional)
                                                                                    • id : String (optional)
                                                                                    • insecureHttps : boolean (optional)
                                                                                      Perform insecure HTTPS negotiation.
                                                                                    • traits (optional)
                                                                                        Array / List of Nested Choice of Objects
                                                                                      • $class: 'ApprovedPullRequestTrait'
                                                                                        Sets if approvals are required before building pull requests.
                                                                                        • strategyId : int
                                                                                          Sets if approvals are required before building pull requests.
                                                                                          No approval necessary.
                                                                                          No check of approvals will be performed before building.
                                                                                          Any approval required
                                                                                          Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                          Non-author approval required
                                                                                          Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                          Author and Non-author approval required
                                                                                          Before building the pull request must be approved by the author and a non-author.
                                                                                      • authorInChangelog
                                                                                        • bitbucketAgedRefsTrait
                                                                                          Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                          • retentionDays : String
                                                                                        • bitbucketBranchCommitSkipTrait
                                                                                          Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                          • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                            Discovers branches in the repository.
                                                                                            • bitbucketBuildStatusNotifications
                                                                                              Configure the Bitbucket notifications.
                                                                                              • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                              • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                            • bitbucketCommitSkipTrait
                                                                                              Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                              • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                • browser
                                                                                                    Nested Choice of Objects
                                                                                                  • assembla
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                  • $class: 'BacklogGitRepositoryBrowser'
                                                                                                    • repoName : String
                                                                                                    • repoUrl : String
                                                                                                  • bitbucketServer
                                                                                                    • repoUrl : String
                                                                                                      Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                  • bitbucket
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                  • cgit
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                  • fisheye
                                                                                                    • repoUrl : String
                                                                                                      Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                  • gitblit
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository.
                                                                                                    • projectName : String
                                                                                                      Specify the name of the project in GitBlit.
                                                                                                  • $class: 'GitBucketBrowser'
                                                                                                    • url : String
                                                                                                  • gitLab
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                    • version : String (optional)
                                                                                                      Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                  • gitLabBrowser
                                                                                                    Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                    • projectUrl : String
                                                                                                      Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                  • gitList
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                  • gitWeb
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                  • $class: 'GiteaBrowser'
                                                                                                    • repoUrl : String
                                                                                                      Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                  • github
                                                                                                    • repoUrl : String
                                                                                                      Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                  • gitiles
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                  • $class: 'GitoriousWeb'
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                  • gogs
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                  • kiln
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                  • phabricator
                                                                                                    • repoUrl : String
                                                                                                      Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                    • repo : String
                                                                                                      Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                  • redmine
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                  • rhodeCode
                                                                                                    • repoUrl : String
                                                                                                      Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                  • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                    • repoUrl : String
                                                                                                      Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                  • $class: 'Stash'
                                                                                                    • repoUrl : String
                                                                                                      Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                  • teamFoundation
                                                                                                    • repoUrl : String
                                                                                                      Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                      If TFS is also used as the repository server, this can usually be left blank.

                                                                                                  • $class: 'TracGitRepositoryBrowser'
                                                                                                    • $class: 'TuleapBrowser'
                                                                                                      Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                      • repositoryUrl : String
                                                                                                        The URL is the web URL of the Tuleap Git repository.
                                                                                                    • viewgit
                                                                                                      • repoUrl : String
                                                                                                        Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                      • projectName : String
                                                                                                        Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                • $class: 'BitbucketJiraValidatorTrait'
                                                                                                  Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                  • jiraServerIdx : int
                                                                                                • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                  Discovers open pull requests in the repository.
                                                                                                  • buildStatusNameCustomPart
                                                                                                    Customize the pipeline status name used by Jenkins
                                                                                                    • buildStatusNameCustomPart : String (optional)
                                                                                                      Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                    • buildStatusNameOverwrite : boolean (optional)
                                                                                                      Overwrites the build status name including the jenkinsci default part.
                                                                                                      Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                    • ignoreTypeInStatusName : boolean (optional)
                                                                                                  • $class: 'ChangeDiscoveryTrait'
                                                                                                    • queryString : String

                                                                                                      Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                      Examples:

                                                                                                      • -is:wip
                                                                                                        does not include work-in-progress changes
                                                                                                      • is:private
                                                                                                        includes private changes

                                                                                                  • checkoutOption
                                                                                                    • extension
                                                                                                        Nested Object
                                                                                                      • timeout : int
                                                                                                        Specify a timeout (in minutes) for checkout.
                                                                                                        This option overrides the default timeout of 10 minutes.
                                                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                  • cleanAfterCheckout
                                                                                                    • extension
                                                                                                        Nested Object
                                                                                                        Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                  • cleanBeforeCheckout
                                                                                                    • extension
                                                                                                        Nested Object
                                                                                                        Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                  • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                    When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                    • cloneOption
                                                                                                      • extension
                                                                                                          Nested Object
                                                                                                        • shallow : boolean
                                                                                                          Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                        • noTags : boolean
                                                                                                          Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                        • reference : String
                                                                                                          Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                          This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                        • timeout : int
                                                                                                          Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                        • depth : int (optional)
                                                                                                          Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                        • honorRefspec : boolean (optional)
                                                                                                          Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                    • $class: 'DisableStatusUpdateTrait'
                                                                                                      Disables notifications (commit status updates) to GitHub for builds.
                                                                                                      • discoverOtherRefs
                                                                                                        Discovers other specified refs on the repository.
                                                                                                        • ref : String

                                                                                                          The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                          Example: test/*/merged

                                                                                                        • nameMapping : String (optional)

                                                                                                          Mapping for how the ref can be named in for example the @Library.
                                                                                                          Example: test-@{1}
                                                                                                          Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                          By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                      • $class: 'FilterChecksTrait'
                                                                                                        • queryOperator
                                                                                                          • Values: ID, SCHEME
                                                                                                        • queryString : String
                                                                                                          Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                      • gitLabForkDiscovery
                                                                                                        Discovers merge requests where the origin project is a fork of the target project.
                                                                                                        • strategyId : int
                                                                                                          Determines how merge requests are discovered:
                                                                                                          Merging the merge request with the current target branch revision
                                                                                                          Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                          The current merge request revision
                                                                                                          Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                          Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                          Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                        • trust

                                                                                                          One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                          Other plugins can extend the available trust policies. The default policies are:

                                                                                                          Nobody
                                                                                                          Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                          Members
                                                                                                          Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                          Trusted Members
                                                                                                          Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                          Everyone
                                                                                                          All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                          • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                        • buildMRForksNotMirror : boolean (optional)
                                                                                                          Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                      • browser
                                                                                                        • browser
                                                                                                            Nested Choice of Objects
                                                                                                          • assembla
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                          • $class: 'BacklogGitRepositoryBrowser'
                                                                                                            • repoName : String
                                                                                                            • repoUrl : String
                                                                                                          • bitbucketServer
                                                                                                            • repoUrl : String
                                                                                                              Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                          • bitbucket
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                          • cgit
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                          • fisheye
                                                                                                            • repoUrl : String
                                                                                                              Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                          • gitblit
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository.
                                                                                                            • projectName : String
                                                                                                              Specify the name of the project in GitBlit.
                                                                                                          • $class: 'GitBucketBrowser'
                                                                                                            • url : String
                                                                                                          • gitLab
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                            • version : String (optional)
                                                                                                              Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                          • gitLabBrowser
                                                                                                            Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                            • projectUrl : String
                                                                                                              Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                          • gitList
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                          • gitWeb
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                          • $class: 'GiteaBrowser'
                                                                                                            • repoUrl : String
                                                                                                              Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                          • github
                                                                                                            • repoUrl : String
                                                                                                              Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                          • gitiles
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                          • $class: 'GitoriousWeb'
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                          • gogs
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                          • kiln
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                          • phabricator
                                                                                                            • repoUrl : String
                                                                                                              Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                            • repo : String
                                                                                                              Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                          • redmine
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                          • rhodeCode
                                                                                                            • repoUrl : String
                                                                                                              Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                          • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                            • repoUrl : String
                                                                                                              Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                          • $class: 'Stash'
                                                                                                            • repoUrl : String
                                                                                                              Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                          • teamFoundation
                                                                                                            • repoUrl : String
                                                                                                              Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                              If TFS is also used as the repository server, this can usually be left blank.

                                                                                                          • $class: 'TracGitRepositoryBrowser'
                                                                                                            • $class: 'TuleapBrowser'
                                                                                                              Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                              • repositoryUrl : String
                                                                                                                The URL is the web URL of the Tuleap Git repository.
                                                                                                            • viewgit
                                                                                                              • repoUrl : String
                                                                                                                Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                              • projectName : String
                                                                                                                Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                        • gitHubAgedRefsTrait
                                                                                                          Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                          • retentionDays : String
                                                                                                        • gitHubBranchCommitSkipTrait
                                                                                                          Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                          • gitHubCommitSkipTrait
                                                                                                            Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                            • $class: 'GitHubJiraValidatorTrait'
                                                                                                              Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                              • jiraServerIdx : int
                                                                                                            • gitHubSourceChecks
                                                                                                              • verboseConsoleLog : boolean (optional)
                                                                                                                If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                            • gitHubStatusChecks
                                                                                                              • name : String (optional)
                                                                                                              • skip : boolean (optional)
                                                                                                              • skipNotifications : boolean (optional)
                                                                                                                If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                              • skipProgressUpdates : boolean (optional)
                                                                                                              • suppressLogs : boolean (optional)
                                                                                                              • unstableBuildNeutral : boolean (optional)
                                                                                                            • lfs
                                                                                                              • gitlabAvatar
                                                                                                                • disableProjectAvatar : boolean (optional)
                                                                                                                  Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                              • gitlabMarkUnstableAsSuccess
                                                                                                                • markUnstableAsSuccess : boolean (optional)
                                                                                                              • gitlabSkipNotifications
                                                                                                                • gitTool
                                                                                                                  • gitTool : String
                                                                                                                • gitLabHookRegistration
                                                                                                                  • webHookMode : String
                                                                                                                  • systemHookMode : String
                                                                                                                • gitHubIgnoreDraftPullRequestFilter
                                                                                                                  • ignoreOnPush
                                                                                                                    • jervisFilter

                                                                                                                      This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                      For Tags:

                                                                                                                      • It will filter for the tag name.

                                                                                                                      For Branches:

                                                                                                                      • It will filter for the branch name.
                                                                                                                      • It will filter for pull requests destined for the branch name.

                                                                                                                      Example YAML

                                                                                                                      branches:
                                                                                                                        only:
                                                                                                                          - main
                                                                                                                      

                                                                                                                      More on specify branches and tags to build

                                                                                                                      By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                      Allow or block branches and tags

                                                                                                                      You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                      # block branches from building
                                                                                                                      branches:
                                                                                                                        except:
                                                                                                                          - legacy
                                                                                                                          - experimental
                                                                                                                      
                                                                                                                      # allow only these branches
                                                                                                                      branches:
                                                                                                                        only:
                                                                                                                          - main
                                                                                                                          - stable
                                                                                                                      

                                                                                                                      The same YAML can be applied to tags.

                                                                                                                      # block tags from building
                                                                                                                      tags:
                                                                                                                        except:
                                                                                                                          - .*-rc
                                                                                                                          - .*-beta
                                                                                                                      
                                                                                                                      # allow only these tags
                                                                                                                      tags:
                                                                                                                        only:
                                                                                                                          - v[.0-9]+
                                                                                                                      

                                                                                                                      If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                      Using regular expressions

                                                                                                                      You can use regular expressions to allow or block branches:

                                                                                                                      branches:
                                                                                                                        only:
                                                                                                                          - main
                                                                                                                          - /^[.0-9]+-hotfix$/
                                                                                                                      

                                                                                                                      Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                      • yamlFileName : String

                                                                                                                        The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                        For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                    • localBranch
                                                                                                                      • logComment
                                                                                                                        • logSuccess : boolean (optional)
                                                                                                                          Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                        • sudoUser : String (optional)
                                                                                                                          Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                      • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                        • browser
                                                                                                                            Nested Choice of Objects
                                                                                                                          • $class: 'FishEye'
                                                                                                                            • url : String
                                                                                                                              Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                          • $class: 'GoogleCode'
                                                                                                                            • url : String
                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                          • $class: 'HgWeb'
                                                                                                                            • url : String
                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                          • $class: 'Kallithea'
                                                                                                                            • url : String
                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                          • $class: 'KilnHG'
                                                                                                                            • url : String
                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                          • $class: 'RhodeCode'
                                                                                                                            • url : String
                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                          • $class: 'RhodeCodeLegacy'
                                                                                                                            • url : String
                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                          • $class: 'ScmManager'
                                                                                                                            • url : String
                                                                                                                              Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                      • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                        • installation : String
                                                                                                                      • multiBranchProjectDisplayNaming
                                                                                                                        Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                        With this trait, that additional information can be used for the job display names.
                                                                                                                        Note: Job display name changes do not trigger builds.
                                                                                                                        • displayNamingStrategy
                                                                                                                          The different strategies:
                                                                                                                          • Job display name with fallback to name:
                                                                                                                            Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                            Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                          • Name and, if available, display name:
                                                                                                                            Joins the raw name and the branch source plugin's display name
                                                                                                                            Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                          • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                      • gitHubNotificationContextTrait
                                                                                                                        Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                        • contextLabel : String
                                                                                                                          The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                        • typeSuffix : boolean

                                                                                                                          Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                        • multipleStatusDelimiter : String (optional)
                                                                                                                          The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                        • multipleStatuses : boolean (optional)
                                                                                                                          Configure multiple status notifications to be sent to GitHub.
                                                                                                                      • gitLabOriginDiscovery
                                                                                                                        Discovers merge requests where the origin project is the same as the target project.
                                                                                                                        • strategyId : int
                                                                                                                          Determines how merge requests are discovered:
                                                                                                                          Merging the merge request with the current target branch revision
                                                                                                                          Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                          The current merge request revision
                                                                                                                          Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                          Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                          Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                      • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                        • inclusionField : String
                                                                                                                          If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                        • exclusionField : String
                                                                                                                          Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                      • $class: 'PreBuildMergeTrait'
                                                                                                                        • extension
                                                                                                                            Nested Object
                                                                                                                            These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                          • options
                                                                                                                              Nested Object
                                                                                                                            • mergeTarget : String
                                                                                                                              The name of the branch within the named repository to merge to, such as master.
                                                                                                                            • fastForwardMode (optional)
                                                                                                                              Merge fast-forward mode selection.
                                                                                                                              The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                              For more information, see the Git Merge Documentation
                                                                                                                              • Values: FF, FF_ONLY, NO_FF
                                                                                                                            • mergeRemote : String (optional)
                                                                                                                              Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                            • mergeStrategy (optional)
                                                                                                                              Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                              • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                      • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                        • extension
                                                                                                                            Nested Object
                                                                                                                          • gitIntegrationStrategy
                                                                                                                              Nested Choice of Objects
                                                                                                                            • accumulated

                                                                                                                              Accumulated Commit Strategy

                                                                                                                              This strategy merges your commits with the --no-ff switch
                                                                                                                              • shortCommitMessage : boolean (optional)
                                                                                                                            • ffonly

                                                                                                                              Fast Forward only (--ff-only) Strategy

                                                                                                                              This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                              • shortCommitMessage : boolean (optional)
                                                                                                                            • squash

                                                                                                                              Squashed Commit Strategy

                                                                                                                              This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                            • integrationBranch : String

                                                                                                                              What to specify

                                                                                                                              The branch name must match your integration branch name. No trailing slash.

                                                                                                                              Merge is performed the following way

                                                                                                                              Squash commit
                                                                                                                                          git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                          git merge --squash <Branch matched by git>
                                                                                                                                          git commit -C <Branch matched by git>
                                                                                                                              Accumulated commit
                                                                                                                                          git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                          git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                              When changes are pushed to the integration branch?

                                                                                                                              Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                          git push <Repository name> <Branch name>
                                                                                                                            • repoName : String

                                                                                                                              What to specify

                                                                                                                              The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                              No trailing slash on repository name.

                                                                                                                              Remember to specify this when working with NAMED repositories in Git

                                                                                                                        • pruneStaleBranch
                                                                                                                          • pruneStaleTag
                                                                                                                            • bitbucketPublicRepoPullRequestFilter
                                                                                                                              If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                              • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                • excludeBranchesWithPRs : boolean
                                                                                                                                  Exclude branches for which there is an open pull request
                                                                                                                              • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                Filter github pull requests out by labels matching any labels specified.
                                                                                                                                • labels : String
                                                                                                                                  Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                              • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                Filter github pull requests by labels matching all labels specified.
                                                                                                                                • labels : String
                                                                                                                                  Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                              • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                Filter github pull requests by labels matching any labels specified.
                                                                                                                                • labels : String
                                                                                                                                  Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                              • $class: 'PullRequestNameFilterTrait'
                                                                                                                                Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                • strategyId : int
                                                                                                                                • phrase : String
                                                                                                                                  Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                • ignoreCase : boolean
                                                                                                                                  Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                • regex : boolean
                                                                                                                                  Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                              • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                Filter Bitbucket Pull Requests by source branch.
                                                                                                                                • strategyId : int
                                                                                                                                • phrase : String
                                                                                                                                  Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                • ignoreCase : boolean
                                                                                                                                  Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                • regex : boolean
                                                                                                                                  Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                              • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                Filter Bitbucket Pull Requests by target branch.
                                                                                                                                • strategyId : int
                                                                                                                                • phrase : String
                                                                                                                                  Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                • ignoreCase : boolean
                                                                                                                                  Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                • regex : boolean
                                                                                                                                  Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                              • refSpecs
                                                                                                                                • templates
                                                                                                                                    Array / List of Nested Object
                                                                                                                                  • value : String
                                                                                                                                    A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                              • headRegexFilterWithPRFromOrigin
                                                                                                                                • regex : String
                                                                                                                                  A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                • tagRegex : String
                                                                                                                                  A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                              • remoteName
                                                                                                                                • remoteName : String
                                                                                                                              • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                • sparseCheckoutPaths
                                                                                                                                  • extension
                                                                                                                                      Nested Object

                                                                                                                                      Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                    • sparseCheckoutPaths
                                                                                                                                        Array / List of Nested Object
                                                                                                                                      • path : String
                                                                                                                                • submoduleOption
                                                                                                                                  • extension
                                                                                                                                      Nested Object
                                                                                                                                    • depth : int (optional)
                                                                                                                                      Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                    • disableSubmodules : boolean (optional)
                                                                                                                                      By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                    • parentCredentials : boolean (optional)
                                                                                                                                      Use credentials from the default remote of the parent project.
                                                                                                                                    • recursiveSubmodules : boolean (optional)
                                                                                                                                      Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                    • reference : String (optional)
                                                                                                                                      Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                      This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                      To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                        git init --bare
                                                                                                                                        git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                        git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                        git fetch --all
                                                                                                                                        
                                                                                                                                    • shallow : boolean (optional)
                                                                                                                                      Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                    • threads : int (optional)
                                                                                                                                      Specify the number of threads that will be used to update submodules.
                                                                                                                                      If unspecified, the command line git default thread count is used.
                                                                                                                                    • timeout : int (optional)
                                                                                                                                      Specify a timeout (in minutes) for submodules operations.
                                                                                                                                      This option overrides the default timeout of 10 minutes.
                                                                                                                                      You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                    • trackingSubmodules : boolean (optional)
                                                                                                                                      Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                • mrTriggerComment
                                                                                                                                  • commentBody : String
                                                                                                                                    Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                  • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                • tuleapBranchDiscovery
                                                                                                                                  • tuleapNotifyPullRequest
                                                                                                                                    • tuleapForkPullRequestDiscovery
                                                                                                                                      • tuleapPullRequestDiscovery
                                                                                                                                        • userIdentity
                                                                                                                                          • extension
                                                                                                                                              Nested Object
                                                                                                                                            • name : String

                                                                                                                                              If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                            • email : String

                                                                                                                                              If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                        • bitbucketWebhookConfiguration

                                                                                                                                          Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                          committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                          • committersToIgnore : String
                                                                                                                                        • WebhookListenerBuildConditionsTrait
                                                                                                                                          • alwaysBuildMROpen : boolean (optional)
                                                                                                                                          • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                          • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                          • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                          • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                          • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                          • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                          • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                            GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                        • headWildcardFilterWithPRFromOrigin
                                                                                                                                          • includes : String
                                                                                                                                            Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                          • excludes : String
                                                                                                                                            Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                          • tagIncludes : String
                                                                                                                                            Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                          • tagExcludes : String
                                                                                                                                            Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                        • $class: 'WipeWorkspaceTrait'
                                                                                                                                          • bitbucketBranchDiscovery
                                                                                                                                            Discovers branches on the repository.
                                                                                                                                            • strategyId : int
                                                                                                                                              Determines which branches are discovered.
                                                                                                                                              Exclude branches that are also filed as PRs
                                                                                                                                              If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                              Only branches that are also filed as PRs
                                                                                                                                              Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                              All branches
                                                                                                                                              Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                          • bitbucketForkDiscovery
                                                                                                                                            Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                            • strategyId : int
                                                                                                                                              Determines how pull requests are discovered.
                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                              The current pull request revision
                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                            • trust

                                                                                                                                              One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                              Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                              Nobody
                                                                                                                                              Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                              Forks in the same account
                                                                                                                                              Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                              Everyone
                                                                                                                                              All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                Nested Choice of Objects
                                                                                                                                              • bitbucketTrustEveryone
                                                                                                                                                • bitbucketTrustNobody
                                                                                                                                                  • bitbucketTrustTeam
                                                                                                                                                • bitbucketPullRequestDiscovery
                                                                                                                                                  Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                  • strategyId : int
                                                                                                                                                    Determines how pull requests are discovered.
                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                    The current pull request revision
                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                • bitbucketSshCheckout
                                                                                                                                                  By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                  This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                  • credentialsId : String
                                                                                                                                                    Credentials used to check out sources.

                                                                                                                                                    It must be a SSH key based credential.

                                                                                                                                                • bitbucketTagDiscovery
                                                                                                                                                  Discovers tags on the repository.
                                                                                                                                                  • bitbucketWebhookRegistration

                                                                                                                                                    Overrides the defaults for webhook management.

                                                                                                                                                    Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                    • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                    • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                    The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                    • mode : String
                                                                                                                                                      There are two available modes:
                                                                                                                                                      Disable hook management
                                                                                                                                                      Disables hook management irrespective of the global defaults.
                                                                                                                                                      Use item credentials for hook management
                                                                                                                                                      Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                  • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                    • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                      • dagshubBranchDiscovery
                                                                                                                                                        • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                          • buildOnPullHead : boolean (optional)
                                                                                                                                                            If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                        • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                          • buildOnPullHead : boolean (optional)
                                                                                                                                                            If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                        • dagshubTagDiscovery
                                                                                                                                                          • gitLabBranchDiscovery
                                                                                                                                                            Discovers branches on the repository.
                                                                                                                                                            • strategyId : int
                                                                                                                                                              Determines which branches are discovered.
                                                                                                                                                              Only branches that are not also filed as MRs
                                                                                                                                                              If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                              Only branches that are also filed as MRs
                                                                                                                                                              This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                              All branches
                                                                                                                                                              Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                          • gitLabSshCheckout
                                                                                                                                                            By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                            This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                            • credentialsId : String
                                                                                                                                                              Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                          • gitLabTagDiscovery
                                                                                                                                                            • gitBranchDiscovery
                                                                                                                                                              Discovers branches on the repository.
                                                                                                                                                              • gitTagDiscovery
                                                                                                                                                                Discovers tags on the repository.
                                                                                                                                                                • headRegexFilter
                                                                                                                                                                  • regex : String
                                                                                                                                                                    A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                    NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                • headWildcardFilter
                                                                                                                                                                  • includes : String
                                                                                                                                                                    Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                    NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                  • excludes : String
                                                                                                                                                                    Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                    NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                • headRegexFilterWithPR
                                                                                                                                                                  • regex : String
                                                                                                                                                                    A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                  • tagRegex : String
                                                                                                                                                                    A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                • headWildcardFilterWithPR
                                                                                                                                                                  • includes : String
                                                                                                                                                                    Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                  • excludes : String
                                                                                                                                                                    Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                  • tagIncludes : String
                                                                                                                                                                    Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                  • tagExcludes : String
                                                                                                                                                                    Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                • giteaBranchDiscovery
                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                  • strategyId : int
                                                                                                                                                                    Determines which branches are discovered.
                                                                                                                                                                    Exclude branches that are also filed as PRs
                                                                                                                                                                    If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                    Only branches that are also filed as PRs
                                                                                                                                                                    This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                    Only branches that are also filed as PRs or main
                                                                                                                                                                    Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                    All branches
                                                                                                                                                                    Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                • giteaForkDiscovery
                                                                                                                                                                  Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                  • strategyId : int
                                                                                                                                                                    Determines how pull requests are discovered:
                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                    The current pull request revision
                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                  • trust

                                                                                                                                                                    One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                    Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                    Nobody
                                                                                                                                                                    Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                    Contributors
                                                                                                                                                                    Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                    Everyone
                                                                                                                                                                    All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                    • gitLabTrustMembers
                                                                                                                                                                      • bitbucketTrustTeam
                                                                                                                                                                        • bitbucketTrustEveryone
                                                                                                                                                                          • bitbucketTrustNobody
                                                                                                                                                                            • gitLabTrustEveryone
                                                                                                                                                                              • gitLabTrustNobody
                                                                                                                                                                                • gitLabTrustPermissions
                                                                                                                                                                                  • giteaTrustContributors
                                                                                                                                                                                    • giteaTrustEveryone
                                                                                                                                                                                      • giteaTrustNobody
                                                                                                                                                                                        • gitHubTrustContributors
                                                                                                                                                                                          • gitHubTrustEveryone
                                                                                                                                                                                            • gitHubTrustNobody
                                                                                                                                                                                              • gitHubTrustPermissions
                                                                                                                                                                                            • giteaPullRequestDiscovery
                                                                                                                                                                                              Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                Determines how pull requests are discovered:
                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                            • giteaSSHCheckout
                                                                                                                                                                                              By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                              This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                              • credentialsId : String
                                                                                                                                                                                                Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                            • giteaTagDiscovery
                                                                                                                                                                                              • giteaWebhookRegistration

                                                                                                                                                                                                Overrides the defaults for webhook management.

                                                                                                                                                                                                Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                • mode : String
                                                                                                                                                                                                  There are two available modes:
                                                                                                                                                                                                  Disable hook management
                                                                                                                                                                                                  Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                  Use item credentials for hook management
                                                                                                                                                                                                  Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                              • gitHubBranchDiscovery
                                                                                                                                                                                                Discovers branches on the repository.
                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                  Determines which branches are discovered.
                                                                                                                                                                                                  Exclude branches that are also filed as PRs
                                                                                                                                                                                                  If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                  Only branches that are also filed as PRs
                                                                                                                                                                                                  Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                  All branches
                                                                                                                                                                                                  Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                              • gitHubForkDiscovery
                                                                                                                                                                                                Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                  Determines how pull requests are discovered:
                                                                                                                                                                                                  Merging the pull request with the current target branch revision
                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                  The current pull request revision
                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                  Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                  Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                • trust

                                                                                                                                                                                                  One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                  Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                  Nobody
                                                                                                                                                                                                  Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                  Collaborators
                                                                                                                                                                                                  Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                  Everyone
                                                                                                                                                                                                  All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                  From users with Admin or Write permission
                                                                                                                                                                                                  Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                  • gitHubTrustContributors
                                                                                                                                                                                                    • gitHubTrustEveryone
                                                                                                                                                                                                      • gitHubTrustNobody
                                                                                                                                                                                                        • gitHubTrustPermissions
                                                                                                                                                                                                      • gitHubPullRequestDiscovery
                                                                                                                                                                                                        Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                          Determines how pull requests are discovered:
                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                      • gitHubSshCheckout
                                                                                                                                                                                                        By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                        This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                        • credentialsId : String
                                                                                                                                                                                                          Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                      • gitHubTagDiscovery
                                                                                                                                                                                                        Discovers tags on the repository.
                                                                                                                                                                                                    • gitblit
                                                                                                                                                                                                      • gitblitUri : String
                                                                                                                                                                                                      • checkoutCredentialsId : String
                                                                                                                                                                                                      • scanCredentialsId : String
                                                                                                                                                                                                      • remote : String
                                                                                                                                                                                                        Specify the URL of this remote repository. This uses the same syntax as your git clone command.
                                                                                                                                                                                                      • includes : String
                                                                                                                                                                                                      • excludes : String
                                                                                                                                                                                                      • id : String (optional)
                                                                                                                                                                                                      • browser (optional)
                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                        • assembla
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                        • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                          • repoName : String
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                        • bitbucketServer
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                        • bitbucket
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                        • cgit
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                        • fisheye
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                        • gitblit
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository.
                                                                                                                                                                                                          • projectName : String
                                                                                                                                                                                                            Specify the name of the project in GitBlit.
                                                                                                                                                                                                        • $class: 'GitBucketBrowser'
                                                                                                                                                                                                          • url : String
                                                                                                                                                                                                        • gitLab
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                          • version : String (optional)
                                                                                                                                                                                                            Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                        • gitLabBrowser
                                                                                                                                                                                                          Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                          • projectUrl : String
                                                                                                                                                                                                            Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                        • gitList
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                        • gitWeb
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                        • $class: 'GiteaBrowser'
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                        • github
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                        • gitiles
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                        • $class: 'GitoriousWeb'
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                        • gogs
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                        • kiln
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                        • phabricator
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                          • repo : String
                                                                                                                                                                                                            Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                        • redmine
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                        • rhodeCode
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                        • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                        • $class: 'Stash'
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                        • teamFoundation
                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                            Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                            If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                        • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                          • $class: 'TuleapBrowser'
                                                                                                                                                                                                            Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                            • repositoryUrl : String
                                                                                                                                                                                                              The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                          • viewgit
                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                            • projectName : String
                                                                                                                                                                                                              Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                        • credentialsId : String (optional)
                                                                                                                                                                                                          Credentials used to scan branches and check out sources.
                                                                                                                                                                                                        • extensions (optional)
                                                                                                                                                                                                            Array / List of Nested Choice of Objects
                                                                                                                                                                                                          • authorInChangelog
                                                                                                                                                                                                            The default behavior is to use the Git commit's "Committer" value in Jenkins' build changesets. If this option is selected, the Git commit's "Author" value would be used instead.
                                                                                                                                                                                                            • $class: 'BuildChooserSetting'
                                                                                                                                                                                                              When you are interested in using a job to build multiple heads (most typically multiple branches), you can choose how Jenkins choose what branches to build in what order.

                                                                                                                                                                                                              This extension point in Jenkins is used by many other plugins to control the job to build specific commits. When you activate those plugins, you may see them installing a custom strategy here.

                                                                                                                                                                                                              • buildChooser
                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                • $class: 'AlternativeBuildChooser'
                                                                                                                                                                                                                  • $class: 'AncestryBuildChooser'
                                                                                                                                                                                                                    • maximumAgeInDays : int
                                                                                                                                                                                                                    • ancestorCommitSha1 : String
                                                                                                                                                                                                                  • $class: 'DefaultBuildChooser'
                                                                                                                                                                                                                    • $class: 'DeflakeGitBuildChooser'
                                                                                                                                                                                                                      • $class: 'GerritTriggerBuildChooser'
                                                                                                                                                                                                                        • $class: 'InverseBuildChooser'
                                                                                                                                                                                                                      • buildSingleRevisionOnly
                                                                                                                                                                                                                        Disable scheduling for multiple candidate revisions.
                                                                                                                                                                                                                        If we have 3 branches:
                                                                                                                                                                                                                        ----A--.---.--- B
                                                                                                                                                                                                                                 \-----C
                                                                                                                                                                                                                        jenkins would try to build (B) and (C).
                                                                                                                                                                                                                        This behaviour disables this and only builds one of them.
                                                                                                                                                                                                                        It is helpful to reduce the load of the Jenkins infrastructure when the SCM system like Bitbucket or GitHub should decide what commits to build.
                                                                                                                                                                                                                        • changelogToBranch
                                                                                                                                                                                                                          This method calculates the changelog against the specified branch.
                                                                                                                                                                                                                          • options
                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                            • compareRemote : String
                                                                                                                                                                                                                              Name of the repository, such as origin, that contains the branch you specify below.
                                                                                                                                                                                                                            • compareTarget : String
                                                                                                                                                                                                                              The name of the branch within the named repository to compare against.
                                                                                                                                                                                                                        • checkoutOption
                                                                                                                                                                                                                          • timeout : int
                                                                                                                                                                                                                            Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                        • cleanBeforeCheckout
                                                                                                                                                                                                                          Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                          • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                            Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                        • cleanAfterCheckout
                                                                                                                                                                                                                          Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                          • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                            Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                        • cloneOption
                                                                                                                                                                                                                          • shallow : boolean
                                                                                                                                                                                                                            Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                          • noTags : boolean
                                                                                                                                                                                                                            Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                          • reference : String
                                                                                                                                                                                                                            Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                            This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                          • timeout : int
                                                                                                                                                                                                                            Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                          • depth : int (optional)
                                                                                                                                                                                                                            Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                          • honorRefspec : boolean (optional)
                                                                                                                                                                                                                            Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                        • $class: 'CodeCommitURLHelper'
                                                                                                                                                                                                                          • credentialId : String

                                                                                                                                                                                                                            OPTIONAL: Select the credentials to use.
                                                                                                                                                                                                                            If not specified, defaults to the DefaultAWSCredentialsProviderChain behaviour - *FROM THE JENKINS INSTANCE*

                                                                                                                                                                                                                            In the latter case, usage of IAM Role Profiles seems not to work, thus relying on environment variables / system properties or the ~/.aws/credentials file, thus not recommended.

                                                                                                                                                                                                                          • repositoryName : String
                                                                                                                                                                                                                        • $class: 'DisableRemotePoll'
                                                                                                                                                                                                                          Git plugin uses git ls-remote polling mechanism by default when configured with a single branch (no wildcards!). This compare the latest built commit SHA with the remote branch without cloning a local copy of the repo.

                                                                                                                                                                                                                          If you don't want to / can't use this.

                                                                                                                                                                                                                          If this option is selected, polling will require a workspace and might trigger unwanted builds (see JENKINS-10131).
                                                                                                                                                                                                                          • $class: 'ExcludeFromChangeSet'
                                                                                                                                                                                                                            • $class: 'ExcludeFromPoll'
                                                                                                                                                                                                                              • lfs
                                                                                                                                                                                                                                Enable git large file support for the workspace by pulling large files after the checkout completes. Requires that the controller and each agent performing an LFS checkout have installed `git lfs`.
                                                                                                                                                                                                                                • $class: 'GitSCMChecksExtension'
                                                                                                                                                                                                                                  • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                    If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                • $class: 'GitSCMStatusChecksExtension'
                                                                                                                                                                                                                                  • name : String (optional)
                                                                                                                                                                                                                                  • skip : boolean (optional)
                                                                                                                                                                                                                                  • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                  • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                  • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                • $class: 'GitTagMessageExtension'
                                                                                                                                                                                                                                  If the revision checked out has a git tag associated with it, the tag name will be exported during the build as GIT_TAG_NAME.
                                                                                                                                                                                                                                  If a message was specified when creating the tag, then that message will be exported during the build as the GIT_TAG_MESSAGE environment variable.
                                                                                                                                                                                                                                  If no tag message was specified, the commit message will be used.
                                                                                                                                                                                                                                  If you ticked the Use most recent tag option, and the revision checked out has no git tag associated with it, the parent commits will be searched for a git tag, and the rules stated above will apply to the first parent commit with a git tag.

                                                                                                                                                                                                                                  If the revision has more than one tag associated with it, only the most recent tag will be taken into account, unless the refspec contains "refs/tags/" — i.e. builds are only triggered when certain tag names or patterns are matched — in which case the exact tag name that triggered the build will be used, even if it's not the most recent tag for this commit.
                                                                                                                                                                                                                                  For this reason, if you're not using a tag-specific refspec but you are using the "Create a tag for every build" behaviour, you should make sure that the build-tagging behaviour is configured to run after this "export git tag message" behaviour.

                                                                                                                                                                                                                                  Tag and commit messages which span multiple lines are no problem, though only the first 10000 lines of a tag's message will be exported.
                                                                                                                                                                                                                                  • useMostRecentTag : boolean (optional)
                                                                                                                                                                                                                                • $class: 'IgnoreNotifyCommit'
                                                                                                                                                                                                                                  If checked, this repository will be ignored when the notifyCommit-URL is accessed regardless of if the repository matches or not.
                                                                                                                                                                                                                                  • localBranch
                                                                                                                                                                                                                                    If given, checkout the revision to build as HEAD on this branch.

                                                                                                                                                                                                                                    If selected, and its value is an empty string or "**", then the branch name is computed from the remote branch without the origin. In that case, a remote branch origin/master will be checked out to a local branch named master, and a remote branch origin/develop/new-feature will be checked out to a local branch named develop/newfeature.

                                                                                                                                                                                                                                    Please note that this has not been tested with submodules.

                                                                                                                                                                                                                                    • localBranch : String
                                                                                                                                                                                                                                  • $class: 'MessageExclusion'
                                                                                                                                                                                                                                    • excludedMessage : String
                                                                                                                                                                                                                                      If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed with message matched to Pattern when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.

                                                                                                                                                                                                                                      Exclusion uses Pattern matching

                                                                                                                                                                                                                                      .*\[maven-release-plugin\].*
                                                                                                                                                                                                                                      The example above illustrates that if only revisions with "[maven-release-plugin]" message in first comment line have been committed to the SCM a build will not occur.

                                                                                                                                                                                                                                      You can create more complex patterns using embedded flag expressions.
                                                                                                                                                                                                                                      (?s).*FOO.*
                                                                                                                                                                                                                                      This example will search FOO message in all comment lines.
                                                                                                                                                                                                                                  • $class: 'PathRestriction'
                                                                                                                                                                                                                                    If set, and Jenkins is set to poll for changes, Jenkins will pay attention to included and/or excluded files and/or folders when determining if a build needs to be triggered.

                                                                                                                                                                                                                                    Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.
                                                                                                                                                                                                                                    • includedRegions : String
                                                                                                                                                                                                                                      Each inclusion uses java regular expression pattern matching, and must be separated by a new line. An empty list implies that everything is included.

                                                                                                                                                                                                                                          myapp/src/main/web/.*\.html
                                                                                                                                                                                                                                          myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                                                          myapp/src/main/web/.*\.gif
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                      The example above illustrates that a build will only occur, if html/jpeg/gif files have been committed to the SCM. Exclusions take precedence over inclusions, if there is an overlap between included and excluded regions.
                                                                                                                                                                                                                                    • excludedRegions : String
                                                                                                                                                                                                                                      Each exclusion uses java regular expression pattern matching, and must be separated by a new line.

                                                                                                                                                                                                                                          myapp/src/main/web/.*\.html
                                                                                                                                                                                                                                          myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                                                          myapp/src/main/web/.*\.gif
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                      The example above illustrates that if only html/jpeg/gif files have been committed to the SCM a build will not occur.
                                                                                                                                                                                                                                  • perBuildTag
                                                                                                                                                                                                                                    Create a tag in the workspace for every build to unambiguously mark the commit that was built. You can combine this with Git publisher to push the tags to the remote repository.
                                                                                                                                                                                                                                    • $class: 'PreBuildMerge'
                                                                                                                                                                                                                                      These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                      • options
                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                        • mergeTarget : String
                                                                                                                                                                                                                                          The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                        • fastForwardMode (optional)
                                                                                                                                                                                                                                          Merge fast-forward mode selection.
                                                                                                                                                                                                                                          The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                          For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                          • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                        • mergeRemote : String (optional)
                                                                                                                                                                                                                                          Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                        • mergeStrategy (optional)
                                                                                                                                                                                                                                          Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                          • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                    • pretestedIntegration
                                                                                                                                                                                                                                      • gitIntegrationStrategy
                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                        • accumulated

                                                                                                                                                                                                                                          Accumulated Commit Strategy

                                                                                                                                                                                                                                          This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                          • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                        • ffonly

                                                                                                                                                                                                                                          Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                          This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                          • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                        • squash

                                                                                                                                                                                                                                          Squashed Commit Strategy

                                                                                                                                                                                                                                          This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                        • integrationBranch : String

                                                                                                                                                                                                                                          What to specify

                                                                                                                                                                                                                                          The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                          Merge is performed the following way

                                                                                                                                                                                                                                          Squash commit
                                                                                                                                                                                                                                                      git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                      git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                      git commit -C <Branch matched by git>
                                                                                                                                                                                                                                          Accumulated commit
                                                                                                                                                                                                                                                      git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                      git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                          When changes are pushed to the integration branch?

                                                                                                                                                                                                                                          Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                      git push <Repository name> <Branch name>
                                                                                                                                                                                                                                        • repoName : String

                                                                                                                                                                                                                                          What to specify

                                                                                                                                                                                                                                          The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                          No trailing slash on repository name.

                                                                                                                                                                                                                                          Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                      • pruneStaleBranch
                                                                                                                                                                                                                                        Run "git remote prune" for each remote, to prune obsolete local branches.
                                                                                                                                                                                                                                        • pruneTags
                                                                                                                                                                                                                                          • pruneTags : boolean
                                                                                                                                                                                                                                        • $class: 'RelativeTargetDirectory'
                                                                                                                                                                                                                                          • relativeTargetDir : String
                                                                                                                                                                                                                                            Specify a local directory (relative to the workspace root) where the Git repository will be checked out. If left empty, the workspace root itself will be used.

                                                                                                                                                                                                                                            This extension should not be used in Jenkins Pipeline (either declarative or scripted). Jenkins Pipeline already provides standard techniques for checkout to a subdirectory. Use ws and dir in Jenkins Pipeline rather than this extension.

                                                                                                                                                                                                                                        • $class: 'ScmName'

                                                                                                                                                                                                                                          Unique name for this SCM. Needed when using Git within the Multi SCM plugin.

                                                                                                                                                                                                                                          • name : String
                                                                                                                                                                                                                                        • $class: 'SparseCheckoutPaths'

                                                                                                                                                                                                                                          Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                          • sparseCheckoutPaths
                                                                                                                                                                                                                                              Array / List of Nested Object
                                                                                                                                                                                                                                            • path : String
                                                                                                                                                                                                                                        • submodule
                                                                                                                                                                                                                                          • depth : int (optional)
                                                                                                                                                                                                                                            Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                          • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                            By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                          • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                            Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                          • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                            Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                          • reference : String (optional)
                                                                                                                                                                                                                                            Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                            This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                            To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                              git init --bare
                                                                                                                                                                                                                                              git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                              git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                              git fetch --all
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                          • shallow : boolean (optional)
                                                                                                                                                                                                                                            Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                          • threads : int (optional)
                                                                                                                                                                                                                                            Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                            If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                          • timeout : int (optional)
                                                                                                                                                                                                                                            Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                          • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                            Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                        • $class: 'UserExclusion'
                                                                                                                                                                                                                                          • excludedUsers : String
                                                                                                                                                                                                                                            If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed by users in this list when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.

                                                                                                                                                                                                                                            Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.

                                                                                                                                                                                                                                            Each exclusion uses exact string comparison and must be separated by a new line. User names are only excluded if they exactly match one of the names in this list.

                                                                                                                                                                                                                                            auto_build_user
                                                                                                                                                                                                                                            The example above illustrates that if only revisions by "auto_build_user" have been committed to the SCM a build will not occur.
                                                                                                                                                                                                                                        • $class: 'UserIdentity'
                                                                                                                                                                                                                                          • name : String

                                                                                                                                                                                                                                            If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                          • email : String

                                                                                                                                                                                                                                            If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                        • $class: 'WipeWorkspace'
                                                                                                                                                                                                                                          Delete the contents of the workspace before building, ensuring a fully fresh workspace.
                                                                                                                                                                                                                                        • gitTool : String (optional)
                                                                                                                                                                                                                                        • traits (optional)
                                                                                                                                                                                                                                            Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                          • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                            Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                              Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                              No approval necessary.
                                                                                                                                                                                                                                              No check of approvals will be performed before building.
                                                                                                                                                                                                                                              Any approval required
                                                                                                                                                                                                                                              Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                              Non-author approval required
                                                                                                                                                                                                                                              Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                              Author and Non-author approval required
                                                                                                                                                                                                                                              Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                          • authorInChangelog
                                                                                                                                                                                                                                            • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                              Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                              • retentionDays : String
                                                                                                                                                                                                                                            • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                              Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                              • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                Discovers branches in the repository.
                                                                                                                                                                                                                                                • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                  Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                  • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                  • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                  Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                  • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                    • browser
                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                      • assembla
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                      • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                        • repoName : String
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                      • bitbucketServer
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                      • bitbucket
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                      • cgit
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                      • fisheye
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                      • gitblit
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository.
                                                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                                                          Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                      • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                      • gitLab
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                        • version : String (optional)
                                                                                                                                                                                                                                                          Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                      • gitLabBrowser
                                                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                        • projectUrl : String
                                                                                                                                                                                                                                                          Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                      • gitList
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                      • gitWeb
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                      • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                      • github
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                      • gitiles
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                      • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                      • gogs
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                      • kiln
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                      • phabricator
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                        • repo : String
                                                                                                                                                                                                                                                          Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                      • redmine
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                      • rhodeCode
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                      • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                      • $class: 'Stash'
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                      • teamFoundation
                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                          Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                          If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                      • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                        • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                          Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                          • repositoryUrl : String
                                                                                                                                                                                                                                                            The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                        • viewgit
                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                          • projectName : String
                                                                                                                                                                                                                                                            Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                    • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                      Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                      • jiraServerIdx : int
                                                                                                                                                                                                                                                    • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                      Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                      • buildStatusNameCustomPart
                                                                                                                                                                                                                                                        Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                        • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                          Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                        • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                          Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                          Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                        • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                      • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                        • queryString : String

                                                                                                                                                                                                                                                          Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                          Examples:

                                                                                                                                                                                                                                                          • -is:wip
                                                                                                                                                                                                                                                            does not include work-in-progress changes
                                                                                                                                                                                                                                                          • is:private
                                                                                                                                                                                                                                                            includes private changes

                                                                                                                                                                                                                                                      • checkoutOption
                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                          • timeout : int
                                                                                                                                                                                                                                                            Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                      • cleanAfterCheckout
                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                            Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                          • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                            Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                      • cleanBeforeCheckout
                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                            Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                          • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                            Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                      • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                        When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                        • cloneOption
                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                            • shallow : boolean
                                                                                                                                                                                                                                                              Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                            • noTags : boolean
                                                                                                                                                                                                                                                              Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                            • reference : String
                                                                                                                                                                                                                                                              Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                              This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                            • timeout : int
                                                                                                                                                                                                                                                              Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                              This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                              You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                            • depth : int (optional)
                                                                                                                                                                                                                                                              Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                            • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                              Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                        • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                          Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                          • discoverOtherRefs
                                                                                                                                                                                                                                                            Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                            • ref : String

                                                                                                                                                                                                                                                              The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                              Example: test/*/merged

                                                                                                                                                                                                                                                            • nameMapping : String (optional)

                                                                                                                                                                                                                                                              Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                              Example: test-@{1}
                                                                                                                                                                                                                                                              Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                              By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                          • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                            • queryOperator
                                                                                                                                                                                                                                                              • Values: ID, SCHEME
                                                                                                                                                                                                                                                            • queryString : String
                                                                                                                                                                                                                                                              Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                          • gitLabForkDiscovery
                                                                                                                                                                                                                                                            Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                              Determines how merge requests are discovered:
                                                                                                                                                                                                                                                              Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                              Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                              The current merge request revision
                                                                                                                                                                                                                                                              Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                              Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                              Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                            • trust

                                                                                                                                                                                                                                                              One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                              Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                              Nobody
                                                                                                                                                                                                                                                              Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                              Members
                                                                                                                                                                                                                                                              Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                              Trusted Members
                                                                                                                                                                                                                                                              Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                              Everyone
                                                                                                                                                                                                                                                              All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                              • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                            • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                              Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                          • browser
                                                                                                                                                                                                                                                            • browser
                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                              • assembla
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                              • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                • repoName : String
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                              • bitbucketServer
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                              • bitbucket
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                              • cgit
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                              • fisheye
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                              • gitblit
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                • projectName : String
                                                                                                                                                                                                                                                                  Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                              • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                              • gitLab
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                • version : String (optional)
                                                                                                                                                                                                                                                                  Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                              • gitLabBrowser
                                                                                                                                                                                                                                                                Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                • projectUrl : String
                                                                                                                                                                                                                                                                  Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                              • gitList
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                              • gitWeb
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                              • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                              • github
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                              • gitiles
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                              • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                              • gogs
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                              • kiln
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                              • phabricator
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                • repo : String
                                                                                                                                                                                                                                                                  Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                              • redmine
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                              • rhodeCode
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                              • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                              • $class: 'Stash'
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                              • teamFoundation
                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                  Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                  If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                              • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                  Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                  • repositoryUrl : String
                                                                                                                                                                                                                                                                    The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                • viewgit
                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                  • projectName : String
                                                                                                                                                                                                                                                                    Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                            • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                              Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                              • retentionDays : String
                                                                                                                                                                                                                                                            • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                              Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                              • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                  Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                  • jiraServerIdx : int
                                                                                                                                                                                                                                                                • gitHubSourceChecks
                                                                                                                                                                                                                                                                  • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                    If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                • gitHubStatusChecks
                                                                                                                                                                                                                                                                  • name : String (optional)
                                                                                                                                                                                                                                                                  • skip : boolean (optional)
                                                                                                                                                                                                                                                                  • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                    If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                  • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                  • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                  • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                • lfs
                                                                                                                                                                                                                                                                  • gitlabAvatar
                                                                                                                                                                                                                                                                    • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                      Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                  • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                    • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                  • gitlabSkipNotifications
                                                                                                                                                                                                                                                                    • gitTool
                                                                                                                                                                                                                                                                      • gitTool : String
                                                                                                                                                                                                                                                                    • gitLabHookRegistration
                                                                                                                                                                                                                                                                      • webHookMode : String
                                                                                                                                                                                                                                                                      • systemHookMode : String
                                                                                                                                                                                                                                                                    • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                      • ignoreOnPush
                                                                                                                                                                                                                                                                        • jervisFilter

                                                                                                                                                                                                                                                                          This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                          For Tags:

                                                                                                                                                                                                                                                                          • It will filter for the tag name.

                                                                                                                                                                                                                                                                          For Branches:

                                                                                                                                                                                                                                                                          • It will filter for the branch name.
                                                                                                                                                                                                                                                                          • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                          Example YAML

                                                                                                                                                                                                                                                                          branches:
                                                                                                                                                                                                                                                                            only:
                                                                                                                                                                                                                                                                              - main
                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                          More on specify branches and tags to build

                                                                                                                                                                                                                                                                          By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                          Allow or block branches and tags

                                                                                                                                                                                                                                                                          You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                          # block branches from building
                                                                                                                                                                                                                                                                          branches:
                                                                                                                                                                                                                                                                            except:
                                                                                                                                                                                                                                                                              - legacy
                                                                                                                                                                                                                                                                              - experimental
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          # allow only these branches
                                                                                                                                                                                                                                                                          branches:
                                                                                                                                                                                                                                                                            only:
                                                                                                                                                                                                                                                                              - main
                                                                                                                                                                                                                                                                              - stable
                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                          The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                          # block tags from building
                                                                                                                                                                                                                                                                          tags:
                                                                                                                                                                                                                                                                            except:
                                                                                                                                                                                                                                                                              - .*-rc
                                                                                                                                                                                                                                                                              - .*-beta
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          # allow only these tags
                                                                                                                                                                                                                                                                          tags:
                                                                                                                                                                                                                                                                            only:
                                                                                                                                                                                                                                                                              - v[.0-9]+
                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                          If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                          Using regular expressions

                                                                                                                                                                                                                                                                          You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                          branches:
                                                                                                                                                                                                                                                                            only:
                                                                                                                                                                                                                                                                              - main
                                                                                                                                                                                                                                                                              - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                          Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                          • yamlFileName : String

                                                                                                                                                                                                                                                                            The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                            For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                        • localBranch
                                                                                                                                                                                                                                                                          • logComment
                                                                                                                                                                                                                                                                            • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                              Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                            • sudoUser : String (optional)
                                                                                                                                                                                                                                                                              Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                          • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                            • browser
                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                              • $class: 'FishEye'
                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                              • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                              • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                              • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                              • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                              • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                              • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                              • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                          • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                            • installation : String
                                                                                                                                                                                                                                                                          • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                            Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                            With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                            Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                            • displayNamingStrategy
                                                                                                                                                                                                                                                                              The different strategies:
                                                                                                                                                                                                                                                                              • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                              • Name and, if available, display name:
                                                                                                                                                                                                                                                                                Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                              • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                          • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                            Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                            • contextLabel : String
                                                                                                                                                                                                                                                                              The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                            • typeSuffix : boolean

                                                                                                                                                                                                                                                                              Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                            • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                              The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                            • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                              Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                          • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                            Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                              Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                              Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                              Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                              The current merge request revision
                                                                                                                                                                                                                                                                              Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                              Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                              Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                          • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                            • inclusionField : String
                                                                                                                                                                                                                                                                              If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                            • exclusionField : String
                                                                                                                                                                                                                                                                              Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                          • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                              • options
                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                • mergeTarget : String
                                                                                                                                                                                                                                                                                  The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                  Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                  The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                  For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                  • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                  Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                  Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                  • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                          • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                              • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                • accumulated

                                                                                                                                                                                                                                                                                  Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                  This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                  • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                • ffonly

                                                                                                                                                                                                                                                                                  Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                  This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                  • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                • squash

                                                                                                                                                                                                                                                                                  Squashed Commit Strategy

                                                                                                                                                                                                                                                                                  This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                • integrationBranch : String

                                                                                                                                                                                                                                                                                  What to specify

                                                                                                                                                                                                                                                                                  The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                  Merge is performed the following way

                                                                                                                                                                                                                                                                                  Squash commit
                                                                                                                                                                                                                                                                                              git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                              git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                              git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                  Accumulated commit
                                                                                                                                                                                                                                                                                              git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                              git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                  When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                  Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                              git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                • repoName : String

                                                                                                                                                                                                                                                                                  What to specify

                                                                                                                                                                                                                                                                                  The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                  No trailing slash on repository name.

                                                                                                                                                                                                                                                                                  Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                            • pruneStaleBranch
                                                                                                                                                                                                                                                                              • pruneStaleTag
                                                                                                                                                                                                                                                                                • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                  If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                  • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                    • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                      Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                  • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                    Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                    • labels : String
                                                                                                                                                                                                                                                                                      Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                  • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                    Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                    • labels : String
                                                                                                                                                                                                                                                                                      Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                  • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                    Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                    • labels : String
                                                                                                                                                                                                                                                                                      Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                  • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                    Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                    • phrase : String
                                                                                                                                                                                                                                                                                      Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                    • ignoreCase : boolean
                                                                                                                                                                                                                                                                                      Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                    • regex : boolean
                                                                                                                                                                                                                                                                                      Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                  • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                    Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                    • phrase : String
                                                                                                                                                                                                                                                                                      Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                    • ignoreCase : boolean
                                                                                                                                                                                                                                                                                      Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                    • regex : boolean
                                                                                                                                                                                                                                                                                      Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                  • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                    Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                    • phrase : String
                                                                                                                                                                                                                                                                                      Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                    • ignoreCase : boolean
                                                                                                                                                                                                                                                                                      Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                    • regex : boolean
                                                                                                                                                                                                                                                                                      Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                  • refSpecs
                                                                                                                                                                                                                                                                                    • templates
                                                                                                                                                                                                                                                                                        Array / List of Nested Object
                                                                                                                                                                                                                                                                                      • value : String
                                                                                                                                                                                                                                                                                        A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                  • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                    • regex : String
                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                    • tagRegex : String
                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                  • remoteName
                                                                                                                                                                                                                                                                                    • remoteName : String
                                                                                                                                                                                                                                                                                  • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                    • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                          Nested Object

                                                                                                                                                                                                                                                                                          Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                        • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                            Array / List of Nested Object
                                                                                                                                                                                                                                                                                          • path : String
                                                                                                                                                                                                                                                                                    • submoduleOption
                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                        • depth : int (optional)
                                                                                                                                                                                                                                                                                          Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                        • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                          By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                        • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                          Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                        • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                          Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                        • reference : String (optional)
                                                                                                                                                                                                                                                                                          Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                          This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                          To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                            git init --bare
                                                                                                                                                                                                                                                                                            git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                            git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                            git fetch --all
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                        • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                          Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                        • threads : int (optional)
                                                                                                                                                                                                                                                                                          Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                          If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                        • timeout : int (optional)
                                                                                                                                                                                                                                                                                          Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                        • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                          Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                    • mrTriggerComment
                                                                                                                                                                                                                                                                                      • commentBody : String
                                                                                                                                                                                                                                                                                        Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                      • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                    • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                      • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                        • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                          • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                            • userIdentity
                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                • name : String

                                                                                                                                                                                                                                                                                                  If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                • email : String

                                                                                                                                                                                                                                                                                                  If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                            • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                              Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                              committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                              • committersToIgnore : String
                                                                                                                                                                                                                                                                                            • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                              • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                              • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                              • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                            • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                              • includes : String
                                                                                                                                                                                                                                                                                                Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                              • excludes : String
                                                                                                                                                                                                                                                                                                Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                              • tagIncludes : String
                                                                                                                                                                                                                                                                                                Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                              • tagExcludes : String
                                                                                                                                                                                                                                                                                                Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                            • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                              • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                  Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                  Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                  If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                  Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                  Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                  All branches
                                                                                                                                                                                                                                                                                                  Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                              • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                  Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                  Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                  The current pull request revision
                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                  Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                  Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                • trust

                                                                                                                                                                                                                                                                                                  One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                  Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                  Nobody
                                                                                                                                                                                                                                                                                                  Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                  Forks in the same account
                                                                                                                                                                                                                                                                                                  Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                  Everyone
                                                                                                                                                                                                                                                                                                  All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                  • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                    • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                      • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                    • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                    • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                      By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                      This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                      • credentialsId : String
                                                                                                                                                                                                                                                                                                        Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                        It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                    • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                      Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                      • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                        Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                        Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                        • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                        • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                        The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                        • mode : String
                                                                                                                                                                                                                                                                                                          There are two available modes:
                                                                                                                                                                                                                                                                                                          Disable hook management
                                                                                                                                                                                                                                                                                                          Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                          Use item credentials for hook management
                                                                                                                                                                                                                                                                                                          Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                      • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                        • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                          • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                            • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                              • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                            • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                              • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                            • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                              • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                  Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                  Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                  If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                  Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                  This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                  All branches
                                                                                                                                                                                                                                                                                                                  Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                              • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                • credentialsId : String
                                                                                                                                                                                                                                                                                                                  Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                              • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                  • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                    Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                    • headRegexFilter
                                                                                                                                                                                                                                                                                                                      • regex : String
                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                        NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                    • headWildcardFilter
                                                                                                                                                                                                                                                                                                                      • includes : String
                                                                                                                                                                                                                                                                                                                        Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                        NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                      • excludes : String
                                                                                                                                                                                                                                                                                                                        Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                        NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                    • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                      • regex : String
                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                      • tagRegex : String
                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                    • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                      • includes : String
                                                                                                                                                                                                                                                                                                                        Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                      • excludes : String
                                                                                                                                                                                                                                                                                                                        Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                      • tagIncludes : String
                                                                                                                                                                                                                                                                                                                        Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                      • tagExcludes : String
                                                                                                                                                                                                                                                                                                                        Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                    • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                        Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                        Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                        If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                        This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                        Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                        All branches
                                                                                                                                                                                                                                                                                                                        Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                    • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                      • trust

                                                                                                                                                                                                                                                                                                                        One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                        Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                        Nobody
                                                                                                                                                                                                                                                                                                                        Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                        Contributors
                                                                                                                                                                                                                                                                                                                        Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                        Everyone
                                                                                                                                                                                                                                                                                                                        All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                        • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                          • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                            • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                              • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                  • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                    • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                      • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                        • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                          • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                            • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                              • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                  By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                  This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                  • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                    Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                  • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                    Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                    Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                    • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                    • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                    The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                    • mode : String
                                                                                                                                                                                                                                                                                                                                                      There are two available modes:
                                                                                                                                                                                                                                                                                                                                                      Disable hook management
                                                                                                                                                                                                                                                                                                                                                      Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                      Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                      Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                  • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                      Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                      Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                      If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                      Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                      All branches
                                                                                                                                                                                                                                                                                                                                                      Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                  • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                    • trust

                                                                                                                                                                                                                                                                                                                                                      One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                      Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                      Nobody
                                                                                                                                                                                                                                                                                                                                                      Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                      Collaborators
                                                                                                                                                                                                                                                                                                                                                      Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                      Everyone
                                                                                                                                                                                                                                                                                                                                                      All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                      From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                      Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                          • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                            Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                              Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                              The current pull request revision
                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                          • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                            By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                            This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                            • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                              Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                          • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                            Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                        • gitlab
                                                                                                                                                                                                                                                                                                                                                          • serverName : String
                                                                                                                                                                                                                                                                                                                                                            Select the GitLab Server where you want the projects to be discovered from.
                                                                                                                                                                                                                                                                                                                                                          • projectOwner : String
                                                                                                                                                                                                                                                                                                                                                            Specify the namespace which owns your projects. It can be a user, a group or a subgroup with full path. E.g: If you want projects from subgroup `a` inside group `b`, then `Owner` should be b/a
                                                                                                                                                                                                                                                                                                                                                          • projectPath : String
                                                                                                                                                                                                                                                                                                                                                            Select the project on which you want to perform the Multibranch Pipeline Job.
                                                                                                                                                                                                                                                                                                                                                          • credentialsId : String (optional)
                                                                                                                                                                                                                                                                                                                                                            Checkout credentials is only needed for private projects. Add `SSHPrivateKey` or `Username/Password` to checkout over SSH remote or HTTPS remote respectively.
                                                                                                                                                                                                                                                                                                                                                          • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                          • projectId : long (optional)
                                                                                                                                                                                                                                                                                                                                                          • traits (optional)
                                                                                                                                                                                                                                                                                                                                                              Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                            • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                              Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                Any approval required
                                                                                                                                                                                                                                                                                                                                                                Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                            • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                              • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                              • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                  Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                  • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                    Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                    • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                    • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                  • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                    Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                      • browser
                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                        • assembla
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                        • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                          • repoName : String
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                        • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                        • bitbucket
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                        • cgit
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                        • fisheye
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                        • gitblit
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                          • projectName : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                          • url : String
                                                                                                                                                                                                                                                                                                                                                                        • gitLab
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                          • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                            Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                        • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                          • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                        • gitList
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                        • gitWeb
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                        • github
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                        • gitiles
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                        • gogs
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                        • kiln
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                        • phabricator
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                          • repo : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                        • redmine
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                        • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                        • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                        • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                            Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                            If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                        • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                          • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                            • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                              The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                          • viewgit
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                            • projectName : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                        Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                        • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                        Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                        • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                          Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                          • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                            Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                          • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                            Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                            Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                          • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                          • queryString : String

                                                                                                                                                                                                                                                                                                                                                                            Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                            Examples:

                                                                                                                                                                                                                                                                                                                                                                            • -is:wip
                                                                                                                                                                                                                                                                                                                                                                              does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                            • is:private
                                                                                                                                                                                                                                                                                                                                                                              includes private changes

                                                                                                                                                                                                                                                                                                                                                                        • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                            • timeout : int
                                                                                                                                                                                                                                                                                                                                                                              Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                              This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                              You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                        • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                              Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                            • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                              Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                        • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                              Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                            • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                              Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                        • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                          When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                          • cloneOption
                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                              • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                              • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                              • reference : String
                                                                                                                                                                                                                                                                                                                                                                                Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                              • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                              • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                              • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                          • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                            Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                            • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                              Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                              • ref : String

                                                                                                                                                                                                                                                                                                                                                                                The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                              • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                            • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                              • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                              • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                            • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                              Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                              • trust

                                                                                                                                                                                                                                                                                                                                                                                One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                Nobody
                                                                                                                                                                                                                                                                                                                                                                                Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                Members
                                                                                                                                                                                                                                                                                                                                                                                Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                Everyone
                                                                                                                                                                                                                                                                                                                                                                                All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                              • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                            • browser
                                                                                                                                                                                                                                                                                                                                                                              • browser
                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                • assembla
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                  • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                • cgit
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                • fisheye
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                • gitblit
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                  • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                • gitLab
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                  • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                    Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                  • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                • gitList
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                • github
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                • gitiles
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                • gogs
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                • kiln
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                • phabricator
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                  • repo : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                • redmine
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                    Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                    If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                    • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                      The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                  • viewgit
                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                    • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                      Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                              • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                              • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                  Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                    Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                    • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                  • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                    • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                      If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                  • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                    • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                    • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                    • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                      If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                    • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                    • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                    • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                  • lfs
                                                                                                                                                                                                                                                                                                                                                                                    • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                      • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                        Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                    • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                      • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                    • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                      • gitTool
                                                                                                                                                                                                                                                                                                                                                                                        • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                      • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                        • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                        • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                      • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                        • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                          • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                            This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                            For Tags:

                                                                                                                                                                                                                                                                                                                                                                                            • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                            For Branches:

                                                                                                                                                                                                                                                                                                                                                                                            • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                            • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                            Example YAML

                                                                                                                                                                                                                                                                                                                                                                                            branches:
                                                                                                                                                                                                                                                                                                                                                                                              only:
                                                                                                                                                                                                                                                                                                                                                                                                - main
                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                            More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                            By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                            Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                            You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                            # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                            branches:
                                                                                                                                                                                                                                                                                                                                                                                              except:
                                                                                                                                                                                                                                                                                                                                                                                                - legacy
                                                                                                                                                                                                                                                                                                                                                                                                - experimental
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                            branches:
                                                                                                                                                                                                                                                                                                                                                                                              only:
                                                                                                                                                                                                                                                                                                                                                                                                - main
                                                                                                                                                                                                                                                                                                                                                                                                - stable
                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                            The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                            # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                            tags:
                                                                                                                                                                                                                                                                                                                                                                                              except:
                                                                                                                                                                                                                                                                                                                                                                                                - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                            tags:
                                                                                                                                                                                                                                                                                                                                                                                              only:
                                                                                                                                                                                                                                                                                                                                                                                                - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                            If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                            Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                            You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                            branches:
                                                                                                                                                                                                                                                                                                                                                                                              only:
                                                                                                                                                                                                                                                                                                                                                                                                - main
                                                                                                                                                                                                                                                                                                                                                                                                - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                            Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                            • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                              The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                              For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                          • localBranch
                                                                                                                                                                                                                                                                                                                                                                                            • logComment
                                                                                                                                                                                                                                                                                                                                                                                              • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                              • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                              • browser
                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                              • installation : String
                                                                                                                                                                                                                                                                                                                                                                                            • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                              Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                              With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                              Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                              • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                  Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                  Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                  Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                  Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                            • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                              Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                              • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                              • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                              • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                              • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                            • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                              Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                              • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                              • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                  These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                • options
                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                  • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                    The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                  • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                    Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                    The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                    For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                    • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                  • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                    Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                  • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                    Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                    • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                  • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                    Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                    This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                    • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                  • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                    Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                    This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                    • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                  • squash

                                                                                                                                                                                                                                                                                                                                                                                                    Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                    This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                  • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                    What to specify

                                                                                                                                                                                                                                                                                                                                                                                                    The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                    Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                    Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                    Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                    When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                    Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                  • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                    What to specify

                                                                                                                                                                                                                                                                                                                                                                                                    The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                    No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                    Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                              • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                    If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                      • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                        Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                      Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                        Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                      Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                        Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                      Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                        Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                      Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                      • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                        Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                      • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                        Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                      • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                        Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                      Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                      • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                        Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                      • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                        Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                      • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                        Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                      Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                      • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                        Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                      • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                        Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                      • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                        Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                    • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                      • templates
                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                        • value : String
                                                                                                                                                                                                                                                                                                                                                                                                          A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                    • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                      • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                      • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                    • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                      • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                      • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                            Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                          • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                              Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                            • path : String
                                                                                                                                                                                                                                                                                                                                                                                                      • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                          • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                          • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                          • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                          • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                          • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                            This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                            To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                              git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                              git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                              git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                              git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                          • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                          • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                            If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                          • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                          • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                      • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                        • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                          Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                        • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                      • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                        • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                          • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                            • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                              • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                  • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                    If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                  • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                    If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                              • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                  GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                              • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                  Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                  Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                  Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                  Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                    Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                    Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                    If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                    All branches
                                                                                                                                                                                                                                                                                                                                                                                                                    Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                  • trust

                                                                                                                                                                                                                                                                                                                                                                                                                    One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                    Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                    Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                    Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                    Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                    Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                    All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                        By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                        This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                        • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                          Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                          It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                          Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                          Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                          • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                          • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                          The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                          • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                            There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                            Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                            Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                            Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                            Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                            • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                  If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                  If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                              • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                    This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                    All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                    Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                  By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                  This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                  • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                      • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                          NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                      • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                        • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                          Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                          NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                        • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                          Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                          NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                      • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                        • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                      • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                        • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                          Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                        • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                          Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                        • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                          Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                        • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                          Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                          Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                          If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                          Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                          This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                          Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                          All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                          Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                        • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                          One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                          Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                          Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                          Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                          All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • git
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GiteaSCMSource'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • globalLib
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • credential : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A Perforce Depot path to the library.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For example: //depot/myLibrary/...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • charset : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • excludes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • filter (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • latest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • latestChange : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • latestWithPin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • latestWithPin : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Polling latest change with pin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled, in case of a pinned checkout, polling ignores the pin or the label specified in the checkout step and polls till the latest change.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • pathFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Depot path filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Changes can be filtered to not trigger a build; if all the files within a change match the specified path, the build is filtered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For example, with a Filter of " //depot/main/tests ":

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case A (change will be filtered):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/index.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/001/test.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/002/test.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case B (change will not be filtered, as build.xml is outside of the filter):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/src/build.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/004/test.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/005/test.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This is not Perforce syntax. Use of ... and * patterns are not supported. Only paths to directories are supported.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • viewPattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • patternText : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Java Pattern filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Changes can be filtered to not trigger a build; if none of the files within a change match a Java pattern (regular expression) listed, the build is filtered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For example, with the following regular expressions:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  //depot/main/tests.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  //depot/main/src/.*\.cpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  //depot/main/build/.*(?:\.rb|\.py|\.bat|Jenkinsfile)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  //depot/main/lib/(?!Lib1|Lib2).*

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case A (change will not be filtered, as these files match our first pattern on "tests"):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/CONTRIUBTING.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/001/index.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case B (Be careful with incomplete file paths! Change will NOT be filtered,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  as this file matches a pattern which was likely intended as describing a "tests/" directory.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests.doc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case C (change will NOT be filtered, as all files match our fourth pattern looking for script files in 'build/'):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/build/rbs/deploy_server.rb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/build/deploy/deploy.bat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/build/Jenkinsfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case D (change will be filtered, as no file matches our second pattern for ".cpp" files under "main/src"):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/src/howto.doc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/src/oldmain.c
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/src/art/splash.bmp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/src/bt/funnelcake.php

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case E (change will be filtered. Lib1 is included in a negative lookahead, and thus is excluded.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/lib/Lib1/build.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • caseSensitive : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • incremental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • perChange : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Polling per change

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled, only the one, oldest changelist returned by polling is built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If P4_INCREMENTAL environment variable (or build parameter) is set to "false", polling per change is ignored and all changelists are built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • userFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • user : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  User name filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Changes can be filtered to not trigger a build; if the owner of a change matches the specified name, the build is filtered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • viewFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • viewMask : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  View Mask filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Changes can be filtered to not trigger a build; if none of the files within a change are contained in the view mask, the build is filtered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For example, with a View Mask Filter of:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  //depot/main/tests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -//depot/main/tests/001

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case A (change will not be filtered, as index.xml is in the view mask):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/index.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/001/test.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case B (change will not be filtered, as index.xml is in the view mask):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/test/index.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/src/build.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case C (change will be filtered, as no file is in the view mask):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/src/build.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Case D (change will be filtered, as no file is in the view mask):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/src/build.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • //depot/main/tests/001/test.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • format : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • includes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • populate (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • autoClean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • replace : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  REPLACE missing/modified files

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Perforce will check out and overwrite any depot files which are either missing from workspace, or have been modified locally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • delete : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DELETE generated files

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Perforce will delete any local files that are not in the depot.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • tidy : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • modtime : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • parallel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • enable : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • threads : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minfiles : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minbytes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • previewOnly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • flushOnly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When a build is triggered by Polling, Build Now or an external Action, the workspace will flush only to the specified label or changelist number. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • forceClean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • have : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • parallel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • enable : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • threads : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minfiles : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minbytes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • graphClean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • parallel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • enable : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • threads : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minfiles : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minbytes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • syncOnly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • revert : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • have : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • force : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • modtime : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • parallel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • enable : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • threads : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minfiles : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • minbytes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • traits (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitTool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For Tags:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For Branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Example YAML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - legacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - experimental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - stable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • logComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • installation : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • multiGraph
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'MercurialSCMSource'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • scmManager
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • scmManagerSvn
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • fromScm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • multiStreams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'SubversionSCMSource'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • multiSwarm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Tuleap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • BbS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • credentialsId : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When running a job, Jenkins requires credentials to authenticate with Bitbucket Server. For example, to checkout the source code for builds. To do this, it needs credentials with access to the projects and repositories you want it to build from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can provide Jenkins with credentials here by:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • selecting credentials from the list
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • adding credentials as a Username with password (for the password, you can enter a Bitbucket Server password or a Bitbucket Server personal access token)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                In addition, you can provide Jenkins with SSH credentials below. If you do, Jenkins will use them for clone operations instead of the credentials you select here.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • sshCredentialsId : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If specified, Jenkins will use these credentials to check out the source code for builds. If no SSH credentials are specified, Jenkins will use the basic credentials instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To provide Jenkins with SSH credentials, you can:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • choose credentials from the list
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • add credentials as a SSH Username with private key (the username must be "git")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • traits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitTool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For Tags:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For Branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Example YAML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - legacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - experimental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - stable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • logComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • installation : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enter the name of the Bitbucket Server project containing the repository you want Jenkins to build from. To find a project, start typing. If it doesn't appear in the search results, the credentials that you've chosen may not have read access to it and you'll need to provide different credentials.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  To get Jenkins to build from a personal repository, enter a tilde (~) followed by repository owner's username. For example, ~jsmith.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repositoryName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enter the Bitbucket Server repository you want Jenkins to build from. To find a repository, start typing. If it doesn't appear in the search results, the credentials that you've chosen may not have read access to it and you'll need to provide different credentials.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  To get Jenkins to build from a personal repository, enter its slug. This is the URL-friendly version of the repository name. For example, a repository called my example repo will have the slug my-example-repo, and you can see this in its URL, https://bitbucketserver.mycompany.com/myproject/my-example-repo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • serverId : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Choose the Bitbucket Server instance containing the repository you want Jenkins to build from. If you can't find your instance, check this plugin's configuration and try again.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • mirrorName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Choose the location that Jenkins should clone from when running this build. This can be the primary server or a mirror if one is available. To see available mirrors, first choose a Bitbucket Server project and repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers branches and/or pull requests from a specific repository in either Bitbucket Cloud or a Bitbucket Server instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoOwner : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the name of the Bitbucket Team or Bitbucket User Account.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  It could be a Bitbucket Project also, if using Bitbucket Server. In this case (Bitbucket Server):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use the project key, not the project name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If using a user account instead of a project, add a "~" character before the username, i.e. "~joe".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repository : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The repository to scan.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • autoRegisterHook : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketServerUrl : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • checkoutCredentialsId : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • credentialsId : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Credentials used to scan branches (also the default credentials to use when checking out sources).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For security reasons most credentials are only available when HTTPS is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • excludes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • includes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • serverUrl : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The server to connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The list of servers is configured in the Manage Jenkins » Configure Jenkins › Bitbucket Endpoints screen. The list of servers can include both Bitbucket Cloud and Bitbucket Server instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • traits (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The behaviours control what is discovered from the Bitbucket repository. The behaviours are grouped into a number of categories:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Within repository
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  These behaviours determine what gets discovered. If you do not configure at least one discovery behaviour then nothing will be found!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  General
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  These behaviours affect the configuration of each discovered branch / pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Git
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  These behaviours affect the configuration of each discovered branch / pull request and are specific to Git semantics.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitTool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For Tags:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For Branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Example YAML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - legacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - experimental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - stable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • logComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • installation : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHub
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • handlers (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • events (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • checks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • commitMessagePattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If set, the plugin will only build revisions commited with messages that match the pattern. If 'skip' is selected, any revisions with matching messages will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • exclude : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • matchCriteria : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Inclusion/Exclusion uses pattern matching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                .*\[maven-release-plugin\].*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The example above illustrates that if only revisions with "[maven-release-plugin]" message in first comment line have been committed to the SCM a build will not occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can create more complex patterns using embedded flag expressions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (?s).*FOO.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This example will search FOO message in all comment lines.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • branchCreated
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • deleted
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • hashChanged
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • restriction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • exclude : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • matchAsPattern : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • matchCriteriaStr : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • pullRequests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • events (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • close
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Triggers when a pull request is closed. Works only when pull request was opened and closed between persistence-based trigger runs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • commentPattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Triggers when a comment matching the pattern is posted in a pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For example Test ([A-Za-z0-9 ,!]+) tags please.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • comment : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • commitChanged
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Triggers when a previously built pull request's hash has changed from the previous state (i.e., a new commit is pushed, or force-pushed).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • description
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If given, don't build a pull request if its description contains the given string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • skipMsg : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labelsAdded
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Triggers run when label is added to pull request. Set of labels is considered added only when at least one label of set was newly added (was not saved in local PR previously) AND every label of set exists on remote PR now.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labelsExist
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Triggers when all the given labels are on a pull request, or blocks triggering if all the given labels are on a pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE: This can cause infinite triggers of pull requests when the skip option isn't selected, so be careful.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labelsNotExist
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Triggers or skips triggering when all the given labels are missing from a pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE: This can cause infinite triggers of pull requests when the skip option isn't selected, so be careful.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labelsPatternExists
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Triggers when a label on a pull request matches the given pattern, or blocks triggering when a label matches, as configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE: This can cause infinite triggers of pull requests when the skip option isn't selected, so be careful.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labelsRemoved
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Triggers a build when the label or labels specified are removed from a pull request. Note that with multiple labels, all of the labels must be removed to cause the trigger to fire.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • nonMergeable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • number : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PR number to run additional checks against
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • match : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines whether the pull request number in the trigger event must match to the above PR number. If not, then logic is not applied and the event wouldn't influence on the trigger result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines whether a matching or non matching pull request number in the trigger event, depending on the above "Match number" flag, skips building instead of triggering a build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Open
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Triggers a build of a pull request when the pull request is opened or reopened.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • events (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • created
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • restrictions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • exclude : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • matchAsPattern : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • matchCriteriaStr : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectUrlStr : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoProvider (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubPlugin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cacheConnection : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • manageHooks : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoPermission (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Values: ADMIN, PUSH, PULL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • scmFactory (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • asIsGITScm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitSCM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The git plugin provides fundamental git operations for Jenkins projects. It can poll, fetch, checkout, and merge contents of git repositories.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The git plugin provides an SCM implementation to be used with the Pipeline SCM checkout step. The Pipeline Syntax Snippet Generator guides the user to select git plugin checkout options and provides online help for each of the options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use the Pipeline Snippet Generator to generate a sample pipeline script for the checkout step. Examples of the checkout step include:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See the argument descriptions for more details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The checkout step provides access to all the Pipeline capabilities provided by the git plugin:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        checkout scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [ url: 'https://github.com/jenkinsci/git-plugin' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NOTE: The checkout step is the preferred SCM checkout method. For simpler cases that do not require all the capabilities of the git plugin, the git step can also be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use the Pipeline Snippet Generator to generate a sample pipeline script for the checkout step.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The checkout step can be used in many cases where the git step cannot be used. Refer to the git plugin documentation for detailed descriptions of options available to the checkout step. For example, the checkout step supports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • SHA-1 checkout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Tag checkout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Submodule checkout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Sparse checkout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Large file checkout (LFS)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Reference repositories
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Branch merges
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Repository tagging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Custom refspecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Timeout configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Changelog calculation against a non-default reference
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Stale branch pruning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example: Checkout step with defaults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Checkout from the git plugin source repository using https protocol, no credentials, and the master branch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        checkout scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [ url: 'https://github.com/jenkinsci/git-plugin' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example: Checkout step with https and a specific branch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Checkout from the Jenkins source repository using https protocol, no credentials, and a specific branch (stable-2.289).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        checkout scmGit(branches: [[name: 'stable-2.289']],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [ url: 'https://github.com/jenkinsci/jenkins.git' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example: Checkout step with ssh and a private key credential

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Checkout from the git client plugin source repository using ssh protocol, private key credentials, and the master branch. The credential must be a private key credential if the remote git repository is accessed with the ssh protocol. The credential must be a username / password credential if the remote git repository is accessed with http or https protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        checkout changelog: false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 scm: scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 [ credentialsId: 'my-private-key-credential-id',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   url: 'git@github.com:jenkinsci/git-client-plugin.git' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example: Checkout step with https and changelog disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Checkout from the Jenkins source repository using https protocol, no credentials, the master branch, and changelog calculation disabled. If changelog is false, then the changelog will not be computed for this job. If changelog is true or is not set, then the changelog will be computed. See the workflow scm step documentation for more changelog details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        checkout changelog: false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [ url: 'https://github.com/jenkinsci/credentials-plugin' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example: Checkout step with git protocol and polling disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Checkout from the command line git repository using git protocol, no credentials, the master branch, and no polling for changes. If poll is false, then the remote repository will not be polled for changes. If poll is true or is not set, then the remote repository will be polled for changes. See the workflow scm step documentation for more polling details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        checkout poll: false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [ url: 'git://git.kernel.org/pub/scm/git/git.git ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Argument Descriptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • userRemoteConfigs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the repository to track. This can be a URL or a local file path. Note that for super-projects (repositories with submodules), only a local file path or a complete URL is valid. The following are examples of valid git URLs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ssh://git@github.com/github/git.git
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • git@github.com:github/git.git (short notation for ssh protocol)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ssh://user@other.host.com/~/repos/R.git (to access the repos/R.git repository in the user's home directory)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • https://github.com/github/git.git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If the repository is a super-project, the location from which to clone submodules is dependent on whether the repository is bare or non-bare (i.e. has a working directory).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • If the super-project is bare, the location of the submodules will be taken from .gitmodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • If the super-project is not bare, it is assumed that the repository has each of its submodules cloned and checked out appropriately. Thus, the submodules will be taken directly from a path like ${SUPER_PROJECT_URL}/${SUBMODULE}, rather than relying on information from .gitmodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For a local URL/path to a super-project, git rev-parse --is-bare-repository is used to detect whether the super-project is bare or not.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For a remote URL to a super-project, the ending of the URL determines whether a bare or non-bare repository is assumed:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • If the remote URL ends with .git, a non-bare repository is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • If the remote URL does NOT end with .git, a bare repository is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the URL or path of the git repository. This uses the same syntax as your git clone command.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • name : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ID of the repository, such as origin, to uniquely identify this repository among other remote repositories. This is the same "name" that you use in your git remote command. If left empty, Jenkins will generate unique names for you.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You normally want to specify this when you have multiple remote repositories.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • refspec : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A refspec controls the remote refs to be retrieved and how they map to local refs. If left blank, it will default to the normal behaviour of git fetch, which retrieves all the branch heads as remotes/REPOSITORYNAME/BRANCHNAME. This default behaviour is OK for most cases.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          In other words, the default refspec is "+refs/heads/*:refs/remotes/REPOSITORYNAME/*" where REPOSITORYNAME is the value you specify in the above "name of repository" textbox.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When do you want to modify this value? A good example is when you want to just retrieve one branch. For example, +refs/heads/master:refs/remotes/origin/master would only retrieve the master branch and nothing else.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The plugin uses a default refspec for its initial fetch, unless the "Advanced Clone Option" is set to honor refspec. This keeps compatibility with previous behavior, and allows the job definition to decide if the refspec should be honored on initial clone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Multiple refspecs can be entered by separating them with a space character. +refs/heads/master:refs/remotes/origin/master +refs/heads/develop:refs/remotes/origin/develop retrieves the master branch and the develop branch and nothing else.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See the refspec definition in Git user manual for more details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Credential used to check out sources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        List of branches to build. Jenkins jobs are most effective when each job builds only a single branch. When a single job builds multiple branches, the changelog comparisons between branches often show no changes or incorrect changes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the branches if you'd like to track a specific branch in a repository. If left blank, all branches will be examined for changes and built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The safest way is to use the refs/heads/<branchName> syntax. This way the expected branch is unambiguous.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If your branch name has a / in it make sure to use the full reference above. When not presented with a full path the plugin will only use the part of the string right of the last slash. Meaning foo/bar will actually match bar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If you use a wildcard branch specifier, with a slash (e.g. release/), you'll need to specify the origin repository in the branch names to make sure changes are picked up. So e.g. origin/release/

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Possible options:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • <branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tracks/checks out the specified branch. If ambiguous the first result is taken, which is not necessarily the expected one. Better use refs/heads/<branchName>.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E.g. master, feature1, ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • refs/heads/<branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tracks/checks out the specified branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E.g. refs/heads/master, refs/heads/feature1/master, ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • <remoteRepoName>/<branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tracks/checks out the specified branch. If ambiguous the first result is taken, which is not necessarily the expected one.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Better use refs/heads/<branchName>.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E.g. origin/master
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • remotes/<remoteRepoName>/<branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tracks/checks out the specified branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E.g. remotes/origin/master
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • refs/remotes/<remoteRepoName>/<branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tracks/checks out the specified branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E.g. refs/remotes/origin/master
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • <tagName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This does not work since the tag will not be recognized as tag.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use refs/tags/<tagName> instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E.g. git-2.3.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • refs/tags/<tagName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tracks/checks out the specified tag.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E.g. refs/tags/git-2.3.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • <commitId>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Checks out the specified commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E.g. 5062ac843f2b947733e6a3b105977056821bd352, 5062ac84, ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ${ENV_VARIABLE}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            It is also possible to use environment variables. In this case the variables are evaluated and the result is used as described above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E.g. ${TREEISH}, refs/tags/${TAGNAME}, ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • <Wildcards>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The syntax is of the form: REPOSITORYNAME/BRANCH. In addition, BRANCH is recognized as a shorthand of */BRANCH, '*' is recognized as a wildcard, and '**' is recognized as wildcard that includes the separator '/'. Therefore, origin/branches* would match origin/branches-foo but not origin/branches/foo, while origin/branches** would match both origin/branches-foo and origin/branches/foo.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • :<regular expression>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The syntax is of the form: :regexp. Regular expression syntax in branches to build will only build those branches whose names match the regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Examples:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • :^(?!(origin/prefix)).*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • matches: origin or origin/master or origin/feature
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • does not match: origin/prefix or origin/prefix_123 or origin/prefix-abc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • :origin/release-\d{8}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • matches: origin/release-20150101
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • does not match: origin/release-2015010 or origin/release-201501011 or origin/release-20150101-something
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • :^(?!origin/master$|origin/develop$).*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • matches: origin/branch1 or origin/branch-2 or origin/master123 or origin/develop-123
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • does not match: origin/master or origin/develop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Defines the repository browser that displays changes detected by the git plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitTool : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Name of the git tool to be used for this job. Git tool names are defined in "Global Tool Configuration".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Extensions add new behavior or modify existing plugin behavior for different uses. Extensions help users more precisely tune plugin behavior to meet their needs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Extensions include:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Clone extensions modify the git operations that retrieve remote changes into the agent workspace. The extensions can adjust the amount of history retrieved, how long the retrieval is allowed to run, and other retrieval details.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Checkout extensions modify the git operations that place files in the workspace from the git repository on the agent. The extensions can adjust the maximum duration of the checkout operation, the use and behavior of git submodules, the location of the workspace on the disc, and more.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Changelog extensions adapt the source code difference calculations for different cases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Tagging extensions allow the plugin to apply tags in the current workspace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Build initiation extensions control the conditions that start a build. They can ignore notifications of a change or force a deeper evaluation of the commits when polling.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Merge extensions can optionally merge changes from other branches into the current branch of the agent workspace. They control the source branch for the merge and the options applied to the merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The default behavior is to use the Git commit's "Committer" value in Jenkins' build changesets. If this option is selected, the Git commit's "Author" value would be used instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'BuildChooserSetting'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When you are interested in using a job to build multiple heads (most typically multiple branches), you can choose how Jenkins choose what branches to build in what order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This extension point in Jenkins is used by many other plugins to control the job to build specific commits. When you activate those plugins, you may see them installing a custom strategy here.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • buildChooser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'AlternativeBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'AncestryBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • maximumAgeInDays : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ancestorCommitSha1 : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'DefaultBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'DeflakeGitBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GerritTriggerBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'InverseBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildSingleRevisionOnly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disable scheduling for multiple candidate revisions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If we have 3 branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ----A--.---.--- B
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \-----C
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        jenkins would try to build (B) and (C).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This behaviour disables this and only builds one of them.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        It is helpful to reduce the load of the Jenkins infrastructure when the SCM system like Bitbucket or GitHub should decide what commits to build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • changelogToBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This method calculates the changelog against the specified branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • compareRemote : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Name of the repository, such as origin, that contains the branch you specify below.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • compareTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The name of the branch within the named repository to compare against.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'CodeCommitURLHelper'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • credentialId : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OPTIONAL: Select the credentials to use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If not specified, defaults to the DefaultAWSCredentialsProviderChain behaviour - *FROM THE JENKINS INSTANCE*

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            In the latter case, usage of IAM Role Profiles seems not to work, thus relying on environment variables / system properties or the ~/.aws/credentials file, thus not recommended.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repositoryName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'DisableRemotePoll'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Git plugin uses git ls-remote polling mechanism by default when configured with a single branch (no wildcards!). This compare the latest built commit SHA with the remote branch without cloning a local copy of the repo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If you don't want to / can't use this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If this option is selected, polling will require a workspace and might trigger unwanted builds (see JENKINS-10131).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ExcludeFromChangeSet'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ExcludeFromPoll'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enable git large file support for the workspace by pulling large files after the checkout completes. Requires that the controller and each agent performing an LFS checkout have installed `git lfs`.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GitSCMChecksExtension'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GitSCMStatusChecksExtension'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GitTagMessageExtension'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If the revision checked out has a git tag associated with it, the tag name will be exported during the build as GIT_TAG_NAME.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If a message was specified when creating the tag, then that message will be exported during the build as the GIT_TAG_MESSAGE environment variable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If no tag message was specified, the commit message will be used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If you ticked the Use most recent tag option, and the revision checked out has no git tag associated with it, the parent commits will be searched for a git tag, and the rules stated above will apply to the first parent commit with a git tag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If the revision has more than one tag associated with it, only the most recent tag will be taken into account, unless the refspec contains "refs/tags/" — i.e. builds are only triggered when certain tag names or patterns are matched — in which case the exact tag name that triggered the build will be used, even if it's not the most recent tag for this commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For this reason, if you're not using a tag-specific refspec but you are using the "Create a tag for every build" behaviour, you should make sure that the build-tagging behaviour is configured to run after this "export git tag message" behaviour.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tag and commit messages which span multiple lines are no problem, though only the first 10000 lines of a tag's message will be exported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • useMostRecentTag : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'IgnoreNotifyCommit'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If checked, this repository will be ignored when the notifyCommit-URL is accessed regardless of if the repository matches or not.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If given, checkout the revision to build as HEAD on this branch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If selected, and its value is an empty string or "**", then the branch name is computed from the remote branch without the origin. In that case, a remote branch origin/master will be checked out to a local branch named master, and a remote branch origin/develop/new-feature will be checked out to a local branch named develop/newfeature.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Please note that this has not been tested with submodules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • localBranch : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'MessageExclusion'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludedMessage : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed with message matched to Pattern when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Exclusion uses Pattern matching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .*\[maven-release-plugin\].*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The example above illustrates that if only revisions with "[maven-release-plugin]" message in first comment line have been committed to the SCM a build will not occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      You can create more complex patterns using embedded flag expressions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (?s).*FOO.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This example will search FOO message in all comment lines.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PathRestriction'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If set, and Jenkins is set to poll for changes, Jenkins will pay attention to included and/or excluded files and/or folders when determining if a build needs to be triggered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • includedRegions : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Each inclusion uses java regular expression pattern matching, and must be separated by a new line. An empty list implies that everything is included.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          myapp/src/main/web/.*\.html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          myapp/src/main/web/.*\.gif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The example above illustrates that a build will only occur, if html/jpeg/gif files have been committed to the SCM. Exclusions take precedence over inclusions, if there is an overlap between included and excluded regions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludedRegions : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Each exclusion uses java regular expression pattern matching, and must be separated by a new line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          myapp/src/main/web/.*\.html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          myapp/src/main/web/.*\.gif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The example above illustrates that if only html/jpeg/gif files have been committed to the SCM a build will not occur.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • perBuildTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Create a tag in the workspace for every build to unambiguously mark the commit that was built. You can combine this with Git publisher to push the tags to the remote repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PreBuildMerge'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • pretestedIntegration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Run "git remote prune" for each remote, to prune obsolete local branches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • pruneTags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • pruneTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'RelativeTargetDirectory'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • relativeTargetDir : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a local directory (relative to the workspace root) where the Git repository will be checked out. If left empty, the workspace root itself will be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This extension should not be used in Jenkins Pipeline (either declarative or scripted). Jenkins Pipeline already provides standard techniques for checkout to a subdirectory. Use ws and dir in Jenkins Pipeline rather than this extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ScmName'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Unique name for this SCM. Needed when using Git within the Multi SCM plugin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • name : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'SparseCheckoutPaths'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • submodule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'UserExclusion'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • excludedUsers : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed by users in this list when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Each exclusion uses exact string comparison and must be separated by a new line. User names are only excluded if they exactly match one of the names in this list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            auto_build_user
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The example above illustrates that if only revisions by "auto_build_user" have been committed to the SCM a build will not occur.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'UserIdentity'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'WipeWorkspace'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Delete the contents of the workspace before building, ensuring a fully fresh workspace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • doGenerateSubmoduleConfigurations : boolean (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Removed facility that was intended to test combinations of git submodule versions. Removed in git plugin 4.6.0. Ignores the user provided value and always uses false as its value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • submoduleCfg (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Removed facility that was intended to test combinations of git submodule versions. Removed in git plugin 4.6.0. Ignores the user provided value(s) and always uses empty values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • submoduleName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Removed in git plugin 4.6.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • branches : Array / List of String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Removed in git plugin 4.6.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • noGITScm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoOwner : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the name of the GitHub Organization or GitHub User Account.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repository : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The repository to scan.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repositoryUrl : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTPS URL of the GitHub Organization / User Account and repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GitHub examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • https://github.com/jenkinsci/github-branch-source-plugin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • https://github.com/jenkinsci/github-branch-source-plugin.git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GitHub Enterprise examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • https://myccompany.github.com/jenkinsci/github-branch-source-plugin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • https://myccompany.github.com/jenkinsci/github-branch-source-plugin.git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • configuredByUrl : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • apiUri : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The server to connect to. The list of servers is configured in the Manage Jenkins » Configure System » GitHub Enterprise Servers screen.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildForkPRHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildForkPRMerge : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildOriginBranch : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildOriginBranchWithPR : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildOriginPRHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildOriginPRMerge : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • credentialsId : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Credentials used to scan branches and pull requests, check out sources and mark commit statuses.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Note that only "username with password" credentials are supported. Existing credentials of other kinds will be filtered out. This is because Jenkins uses the GitHub API, which does not support other ways of authentication.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If none is given, only the public repositories will be scanned, and commit status will not be set on GitHub.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If your organization contains private repositories, then you need to specify a credential from a user who has access to those repositories. This is done by creating a "username with password" credential where the password is GitHub personal access tokens. The necessary scope is "repo".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • excludes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • includes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • traits (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The behaviours control what is discovered from the GitHub repository. The behaviours are grouped into a number of categories:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Within repository
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        These behaviours determine what gets discovered. If you do not configure at least one discovery behaviour then nothing will be found!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        General
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        These behaviours affect the configuration of each discovered branch / pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitTool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For Tags:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For Branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example YAML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - legacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - experimental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - stable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • logComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • installation : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • clone : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If checked, every build performs a fresh clone of the SCM rather than locking and updating a common copy. No changelog will be computed. For Git, you are advised to add Advanced clone behaviors and then check Shallow clone and Honor refspec on initial clone and uncheck Fetch tags to make the clone much faster. You may still enable Cache fetched versions on controller for quick retrieval if you prefer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • libraryPath : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A relative path from the root of the SCM to the root of the library. Leave this field blank if the root of the library is the root of the SCM. Note that ".." is not permitted as a path component to avoid security issues.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                libraryResource: Load a resource file from a library

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Reads a resource from a library and returns its content as a plain string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • resource : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Relative (/-separated) path to a resource in a library's /resources folder.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • encoding : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The encoding to use when reading the resource. If left blank, the platform default encoding will be used. Binary files can be read into a Base64-encoded string by specifying "Base64" as the encoding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Was this page helpful?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Please submit your feedback about this page through this quick form.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Alternatively, if you don't wish to complete the quick form, you can simply indicate if you found this page helpful?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See existing feedback here.