Package hudson.plugins.git.extensions.impl

Class PreBuildMerge

  • All Implemented Interfaces:
    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

    • Constructor Detail

      • PreBuildMerge

        @DataBoundConstructor
public PreBuildMerge​(UserMergeOptions options)

    • Method Detail

      • decorateRevisionToBuild

        public hudson.plugins.git.Revision decorateRevisionToBuild​(GitSCM scm,
                                                           Run<?,​?> build,
                                                           org.jenkinsci.plugins.gitclient.GitClient git,
                                                           TaskListener listener,
                                                           hudson.plugins.git.Revision marked,
                                                           hudson.plugins.git.Revision rev)
                                                    throws hudson.plugins.git.GitException,
                                                           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
        Parameters:
        scm - GitSCM object
        build - run context
        git - GitClient object
        listener - build log
        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:
        hudson.plugins.git.GitException - on git error
        IOException - on input or output error
        InterruptedException - when interrupted

      • decorateMergeCommand

        public void decorateMergeCommand​(GitSCM scm,
                                 Run<?,​?> build,
                                 org.jenkinsci.plugins.gitclient.GitClient git,
                                 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
        Parameters:
        scm - GitSCM object
        build - run context
        git - GitClient
        listener - build log
        cmd - merge command to be decorated
        Throws:
        IOException - on input or output error
        InterruptedException - when interrupted
        hudson.plugins.git.GitException - on git error

      • 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
        Returns:
        git client type required for this extension

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object