hudson.plugins.git.extensions.impl

Class PreBuildMerge

java.lang.Object

hudson.model.AbstractDescribableImpl<GitSCMExtension>

hudson.plugins.git.extensions.GitSCMExtension

hudson.plugins.git.extensions.impl.PreBuildMerge

All Implemented Interfaces:

hudson.model.Describable<GitSCMExtension>

public class PreBuildMerge
extends GitSCMExtension

Speculatively merge the selected commit with another branch before the build to answer the "what happens if I were to integrate this feature branch back to the master?" question.

Author:

Nigel Magney, Nicolas Deloof, Andrew Bayer, Kohsuke Kawaguchi

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	PreBuildMerge.DescriptorImpl

Constructor Summary

Constructors

Constructor and Description
PreBuildMerge(UserMergeOptions options)

Method Summary

Methods

Modifier and Type	Method and Description
void	decorateMergeCommand(GitSCM scm, hudson.model.Run<?,?> build, org.jenkinsci.plugins.gitclient.GitClient git, hudson.model.TaskListener listener, org.jenkinsci.plugins.gitclient.MergeCommand cmd) Called before a MergeCommand is executed to allow extensions to alter its behaviour.
hudson.plugins.git.Revision	decorateRevisionToBuild(GitSCM scm, hudson.model.Run<?,?> build, org.jenkinsci.plugins.gitclient.GitClient git, hudson.model.TaskListener listener, hudson.plugins.git.Revision marked, hudson.plugins.git.Revision rev) Called after BuildChooser selects the revision to pick for this build, but before
UserMergeOptions	getOptions()
GitClientType	getRequiredClient() Let extension declare required GitClient implementation.

Methods inherited from class hudson.plugins.git.extensions.GitSCMExtension

beforeCheckout, beforeCheckout, decorate, decorateCheckoutCommand, decorateCheckoutCommand, decorateCloneCommand, decorateCloneCommand, decorateFetchCommand, decorateMergeCommand, decorateRevisionToBuild, getDescriptor, getWorkingDirectory, getWorkingDirectory, isRevExcluded, onCheckoutCompleted, onCheckoutCompleted, onClean, populateEnvironmentVariables, requiresWorkspaceForPolling

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

PreBuildMerge

@DataBoundConstructor
public PreBuildMerge(UserMergeOptions options)

Method Detail

getOptions

public UserMergeOptions getOptions()

decorateRevisionToBuild

public hudson.plugins.git.Revision decorateRevisionToBuild(GitSCM scm,
                                                  hudson.model.Run<?,?> build,
                                                  org.jenkinsci.plugins.gitclient.GitClient git,
                                                  hudson.model.TaskListener listener,
                                                  hudson.plugins.git.Revision marked,
                                                  hudson.plugins.git.Revision rev)
                                                    throws IOException,
                                                           InterruptedException

Description copied from class: GitSCMExtension

Called after BuildChooser selects the revision to pick for this build, but before

This allows extensions to select a derived revision (for example by merging another branch into the chosen revision and returning it) or manipulate the state of the working tree (such as running git-clean.)

GitSCMExtension.decorateRevisionToBuild(GitSCM, Run, GitClient, TaskListener, Revision, Revision) vs BuildChooser

BuildChooser and this method are similar in the sense that they both participate in the process of determining what commits to build. So when a plugin wants to control the commit to be built, you have a choice of these two approaches. The rule of the thumb is to ask yourself if your process takes another commit as an input. BuildChooser is suitable when you do not take any commit as a parameter, and need to precisely control what commit to build. For example the gerrit-trigger plugin looks at a specific build parameter, then retrieves that commit from Gerrit and builds that. GitSCMExtension.decorateRevisionToBuild(GitSCM, Run, GitClient, TaskListener, Revision, Revision) is suitable when you accept arbitrary revision as an input and then create some derivative commits and then build that result. The primary example is for speculative merge with another branch (people use this to answer the question of "what happens if I were to integrate this feature branch back to the master branch?")

Overrides:

decorateRevisionToBuild in class GitSCMExtension

marked - The revision that started this build. (e.g. pre-merge)

rev - The revision selected for this build.

Returns:

The revision selected for this build. Unless you are decorating the given rev, return the value given in the rev parameter.

Throws:

IOException

InterruptedException

decorateMergeCommand

public void decorateMergeCommand(GitSCM scm,
                        hudson.model.Run<?,?> build,
                        org.jenkinsci.plugins.gitclient.GitClient git,
                        hudson.model.TaskListener listener,
                        org.jenkinsci.plugins.gitclient.MergeCommand cmd)
                          throws IOException,
                                 InterruptedException,
                                 hudson.plugins.git.GitException

Description copied from class: GitSCMExtension

Called before a MergeCommand is executed to allow extensions to alter its behaviour.

Overrides:

decorateMergeCommand in class GitSCMExtension

Throws:

IOException

InterruptedException

hudson.plugins.git.GitException

getRequiredClient

public GitClientType getRequiredClient()

Description copied from class: GitSCMExtension

Let extension declare required GitClient implementation. git-plugin will then detect conflicts, and fallback to globally configured default git client

Overrides:

getRequiredClient in class GitSCMExtension