Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.
Section
borderfalse
Column
width50%
Wiki Markup
{jenkins-plugin-info:pluginId=pretested-integration|jiraComponent=pretested-integration}
Column
width20%

Developed by

Image RemovedImage Added

Sponsored by members of the

Image Removed

Image Added

Column
width30%
 

Table of Contents
maxLevel3

Introduction

Excerpt

The Pretested Integration Plugin offers a branchy approach to pretested integration (also known as pre-tested commits), which upholds the invariant; that for a specific branch, known as the integration branch, all commits have been verified.

This plugin is developed by Praqma and sponsored by Atmel - It's maintained in the scope of Joint Open Source Roadmap Alliance (JOSRA).and maintained by the Continuous Delivery Alliance members (earlier named Josra)

The plugin rely relies on the SCM plugin to establish the workspace and then takes over to do the integration . Last in the local workspace of the job. Finally the job make makes the decision whether to like and commit push the result or hate and discard it. To get a comprehensive introduction to how the plugin relies on the SCM plugin please read the blog post at the JOSRA: Pretested Integration Plugin.

Features

  • If you deliver (git push) more than one commit on the ready branch it will be delivered to the integration branch using the strategy.

  • Two strategies are supported: squashed (using git --squash merges) and accumulated (using git --no-ff merges).

  • If you deliver one commit that can be fast-forwarded, it will be.

  • Credentials support for the SCM configuration.

  • Adding the Pretested Integration Plugin publisher as a post-build step is optional, leaving room for more customized jobs.

  • The plugin support Job DSL, scripted and declarative pipeline syntax if you script your jobs.

  • Pretested Integration Plugin can integrate repositories with git submodules if they are processed as part of the git scm additional behavior.

Major version 3 incompatible with earlier version

Starting with version 3.0.0 we have changed the plugin to work as a Git Plugin extension, so you will find under Additional behaviors in your Git SCM configuration.
Earlier it was a build wrapper which was configured in the “Prepare an environment for this build”

The change was necessary in order to support the new Pipeline job types and requires you to migrate your job configuration.

Migration guide from 2.x to 3.x

Job DSL

If you’re using Job DSL to generate your jobs this is an easy fix. Just update your Job DSL script with the new syntax, which is show in the JobDSL example section below.

Manually created jobs

If you’re creating your jobs manually, you’ll need to manually reconfigure your jobs.

When updating the plugin your current configuration will not show so you need to know how your jobs was configured and make the analogue configuration as Git Plugin extension.

Example below in the pictures.

The names of the fields have not changed and the strategies remain unchanged as well.

Build wrapperGit 'Additonal behaviour'

Image Added

Image Added


Additional behaviours → “Use pretested integration” -> Configure Integration branch and repository

Who should upgrade and who should not

  • Users who rely on Multiple SCM plugin should not upgrade to 3.x since we’ve removed support for this plugin in 3.0.0.  If you use this plugin, consider moving to the Pipeline job type instead and leave the deprecated MultiSCM behind.
  • If you use purely FreeStyle jobs in your environment, upgrading to 3.0.0 is recommended. It won't provide any benefits and won’t be strictly necessary, but we recommend to follow along and if you have many manual configured job, take the opportunity to script them using Job DSL or Jenkins Pipeline syntax.
  • If you use Matrix job, you can benefit from version 3.x as the post build step is now optional and thus gives you flexibility to use pretested integration in a Matrix job setup.

Plugin limitations

There is one requirement: You should only try to integrate changes from one repository pr. job.

So see this as a limitation, but it actually a design decision as we will never be able to guarantee an atomic integration of two DVCS repositories as one process.

  • So only configure the Pretested Integration Plugin on one Git repository pr. job

Beside this the Pretested Integration plugin works with most known job types :

  • FreeStyle and Matrix jobs are supported. See the section below for configuring Matrix jobs.

  • Pipeline jobs are also supported, with a small caveat for Multibranch Pipeline: The pipeline is executed before the merge of the Jenkinsfile, so changes you push for the Jenkinsfile will only have effect the next time the pipeline executes.

  • Maven job type are unsupported and we will print a warning, but should function just like the FreeStyle Job type in many cases.

There can be more repositories in your job - only one under integration.

When you use Git SCM with more than 1 repository configured it is absolutely required that you ensure that the remote name is unique pr. repository as we only allow integration of 1 git repo per job. Call them by the saying repository name or simply just origin1, origin2 ...

For Pipeline you also need to make sure you only perform 1 integration in the course of the flow, you can have multiple checkouts, but only one of your repositories can have pretested integration happening, otherwise we cannot reliably determine which branch to delete upon the success of the job.

References

Limitations, requirements and dependencies

  • The plugin only supports the Jenkins Freestyle project (not Maven or Multi-configuration aka. Matrix). In other project types than the Freestyle, the UI of Pretested Integration will not show up.
  • Git 1.9.x must be installed and available on the Jenkins build executor in command line. On Windows we depend on git commands to be available in the Windows command shell (not Git Bash, nor Cygwin).
  • Git configuration dependencies: the user account of the Jenkins build executor must be available to push to your integration repository. This typically means that you have to use either http- or ssh-credentials configured for the user account running the Jenkins slave.

Support and contact

Please send us an email on support@praqma.net if you have a request or question regarding the plugin.

If you find an error or have feature requests, use the Jenkins issue tracker.

Comments and discussions on this page might not always be noticed.

...

Changes in Jenkinsfile (for users of pipeline with Jenkinsfile)

The default behaviour of the pretested integration plugin is to run `jenkinsfile` that is located on the branch that is being integrated, so if branch `ready/457-uses-gradle-instead-of-maven` if being processed by the plugin, it is the file located on that branch that will be executed, not the one on the integration branch.

Conflicts

There can be cases where users have edited the jenkins file, and that can result in a merge conflict. The pretested integration plugin does not handle merge conflict in a Jenkinsfile, so to update the Jenkins file, another strategy must be applied.

1. Change the Jenkins file and merge it to the integration branch (`master`) locally in a separate commit
2. Push it to remote master
3. Delivering the other changes on a ready branch, which also has the updates to the jenkinsfile

If `master` (in the case above) is also being build by a job, that can result in a failing build if the new Jenkinsfile is using resources not yet available. This will however be fixed the moment the `ready`-branch have been integrated.

Support and contact

If you find issues or have questions please contact us using Github issues here https://github.com/Praqma/pretested-integration-plugin/issues

Comments and discussions on this page is not noticed.

Plugin configuration

Tips for matrix job configuration

When you use the Matrix Job type, the merge is performed for each child job in your matrix and even thought the Pretested Integration Plugin post-build step is added we make sure it is only executed once in the parent job. This ensures that we only attempt to remove the branch once during a Matrix build after all childs have completed and have completed successfully.

We assume that your integration process using Pretested Integration Plugin is serialized so only one of this kind of job pr. project is building at the time. Else you're not sure the child jobs are integrating and verifying the same changes.

Manual building

In general you are not able to use 'Build now' with a Pretested Integration Plugin job configuration. The Pretested Integration Plugin is first in action when a "workspace" is handed over from the Git Plugin it will when manually building serve the last build revision again. If that succeeded last time, the revision is deleted after the integration and retrying the integration fails.

 Some successful and failing cases using manual builds are:

  • If last build failed, thus the integration failed, for a non-persistent error (disk problem, licensing problem ...) rebuilding the job can succeed if no other build have been executed since last time.

  • If you have done a job configuration change, and need to trigger the job to test the configuration you typically need to make a commit that triggers the job. Push a commit to a ready branch, or wait for one.

  • There is a work around, that often enables you to build manually: Make the job parametrized with BRANCH_TO_BUILD and use that variable in the 'branch specifier'. Make BRANCH_TO_BUILD have the default ready-branch specifier, so if not given the job works as if there were no parameters. If you now build the job manually, you can type in a branch to build.

Failed and ‘Nothing to do’ statuses when merging

The ‘Nothing to do’ build status is added to your build description in the following scenarios

  • Pushing a development branch that has no changes (result of merge is empty)

  • Using the plugin in a setup with more than 1 remote configured where the build is triggered by repository that does not have pretested integration plugin configured.

Failed builds can happen if there is a merge conflict which cannot be solved by a merge. In this scenario it is up to the user to merge the integration branch into their own development branch to fix their issues and deliver it again.

How Pretested Integration uses credentials

The Pretested Integration plugin will re-use the credentials for configured for the SCM that performed the merge. That means that if you've properly configured credentials in your git plugin, that is, credentials with write acces to your repository no further configuration is required. 

The recommended setup and git workflow

Here is a simple git workflow where you can work on a features branch, and when ready push to a ready-branch. The Pretested Integration plugin, if configured as described will then pick up your changes, merge them and verify them. If verified they are integrated on the integration branch. The ready branch are automatically deleted if integration was successful.

...

  • Use one repository in your job configuration - the integration repository. Avoid using several repositories - model your dependencies in other (better) ways.
  • Name your repository origin
  • Use master as integration branch (destination).
  • Use origin/ready/** as specifier for ready branches - only branches matching this expression will trigger the build

The simple

...

To configure the plugin to pick up ready branches, verify them and deliver them to the integration branch use the following configuration:

Image Removed

Configure the SCM as above.

  • Recommend ready branch specifier is the 'Branch Speciifier' : ready/**
  • Remember to add the two additional behaviours to ensure a clean work space and that old deleted branches are cleaned
  • It is recommended to name your repository in the 'Name' field.

Image Removed

Configure the Pretested Integration plugin with integration branch 'master' and the named repository 'origin'.
There is a Pretested Integration plugin post-build step, which ensure verified changes are published. You don't have to configure it - it is automatically added.

Now you only need to configure your definition of done - the verification. How should the job verify the commits? It can be compile and measure compiler warning, build and run unit tests and check that coverage do not drop.

The simple Git workflow

Get your repository up to date:

Code Block

git fetch --prune

git checkout master

git pull origin master

Create a feature- or development- or... branch

Code Block

git checkout -b feat_1337-improved-login-screen

...

Then push changes to a ready branch, which is basically just a branch following a naming conventions for branches matching ready/**.

Code Block

git push origin feat_1337-improved-login-screen:ready/feat_1337-improved-login-screen

The change will be picked up by the plugin if configured as shown in next sectionthe picture below.

  • You can then delete your local branch and continue with a new feature or development branch.
  • You are free to push to any branch name not matching the ready branch naming convention without triggering an integration build.

This is how the default configuration should look like:

Image Added

And a publisher to delete on success:

Image Added

Integration flow

Below is a simplified diagram of what Pretested Integration actually does once you've pushed your branch to integrate.
At the start, HEAD is at the integration branch, ready to merge in your branch.
In the end the merge result is verified and, if successful, pushed.

Image Added

Help and error messages

*NOT YET DONE - work in progress* (We have gathered We tried to gather some common errors and problems seen, together with some suggested solutions - but not much have been contributed. See Help and error messages)

Demo jobs and example on commit messages and output

We have created some Jenkins job on our public Jenkins master that shows the plugin in action, in the version we have installed (typically latest one or even latest snapshop).

There is actually a demo job you can run, that triggers a demonstration:

The commits end up in our Github test repository called blackhole

Accumulated strategy - build console output

...

Version 2.3.0

...

Version 2.2.3

...

Scripted job examples

The following are examples on how to script jobs using this plugin. Refer to either the pipeline script generator in Jenkins or Job DSL API viewer for all the details.

Job DSL

Example integrating the plugin repository itself using our recommended default configuration
Code Block
java
java
job("pretested-integration-plugin_

...

our-integration-job") {
  scm {
     git {
          remote {
              name("origin")
              url("https://your.repo.com.git")              
          }
          branch("*/ready/**")
      

...

 

...

 

...

 

...

 

...

extensions 

...

{

...

 

...

 

...

 

...

 

...

 

...

         

...

pretestedIntegration("SQUASHED","master","origin")
          }
      }
   }
  publishers {
    pretestedIntegrationPublisher()
  }
}

 Scripted pipeline

 Example integrating the plugin repository itself using our recommended default configuration
Code Block
java
java
node {
    checkout([$class: 'GitSCM', branches: [[name: '*/ready/**']], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'CleanBeforeCheckout'], pretestedIntegration(gitIntegrationStrategy: squash(), integrationBranch: 'master', repoName: 'origin')], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'pipCredentials', url: 'https://your.repo.com.git']]])
    pretestedIntegrationPublisher()
}

Declarative pipeline

Example integrating the plugin repository itself using our recommended default configuration
Code Block
java
java
pipeline {
   agent any
   stages {
       stage("checkout") {
           steps {
               checkout([$class: 'GitSCM', branches: [[name: '*/ready/**']], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'CleanBeforeCheckout'], pretestedIntegration(gitIntegrationStrategy: squash(), integrationBranch: 'master', repoName: 'origin')], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'pipCredentials', url: 'https://your.repo.com.git']]])
           }
       }
       stage("publish") {
           steps {
              

...

 

...

pretestedIntegrationPublisher()

...

 

...

 

...

 

...

 

...

 

...

 

...

 

...

 

...

 

...

 

...

 

...

}

...

 

...

 

...

 

...

 

...

 

...

 

...

 

...

}

...

 

...

 

...

 

...

Accumulated demo job example #32

...

Accumulated demo job example #31

Squashed strategy - build console output

Version 2.3.0

Version 2.2.3

Code Block
[PREINT] Preparing environment using Pretested Integration Plugin 2.3.0-SNAPSHOT (cbd24) 
[PREINT] Checking out integration branch master:
[PREINT]  git checkout -B master origin/master
[pretested-integration-plugin__demo-job-squashed-strategy] $ git checkout -B master origin/master
[PREINT]  git pull origin master
[pretested-integration-plugin__demo-job-squashed-strategy] $ git pull origin master
[PREINT] Preparing to merge changes in commit 26576c087d13a50179a13054cc6edac603271abd on development branch origin/ready/feature-squashed-32 to integration branch master
[PREINT] Collecting commit messages on development branch (for debug printing): origin/ready/feature-squashed-32
[PREINT] Done collecting commit messages
[PREINT] Collecting author of last commit on development branch
[PREINT] Done colecting last commit author: demo-job-user <support@praqma.net> 1435686849 +0200
[PREINT] Starting squash merge - without commit:
[PREINT]  git merge --squash origin/ready/feature-squashed-32
[pretested-integration-plugin__demo-job-squashed-strategy] $ git merge --squash origin/ready/feature-squashed-32
[PREINT] Squash merge done
[PREINT] Merge was successful
[PREINT] Starting to commit squash merge changes:
[PREINT]  git commit --no-edit "--author=demo-job-user <support@praqma.net> 1435686849 +0200"
[pretested-integration-plugin__demo-job-squashed-strategy] $ git commit --no-edit "--author=demo-job-user <support@praqma.net> 1435686849 +0200"
[PREINT] Commit of squashed merge done
[PREINT] Debug print - commit message for squash merge:
Demo commit message for Pretested Integration:

This is a longer commit message about what this commit is about.

We use this commit to illustrate the Prested Integration Plugin commit messages, based on their strategies. There are two demo jobs, one for each strategy and a job that does two commits, one on two different branches to be picked up as ready branches.

[PREINT] Commit was successful
[pretested-integration-plugin__demo-job-squashed-strategy] $ /bin/sh -xe /tmp/hudson3927922213950794742.sh
+ echo Build and verification was successful
Build and verification was successful
[PREINT] Performing pre-verified post build steps
[PREINT] Pushing changes to integration branch:
[PREINT]  git push origin master
[pretested-integration-plugin__demo-job-squashed-strategy] $ git push origin master
[PREINT] Done pushing changes
[PREINT] Deleting development branch:
[PREINT]  git push origin :ready/feature-squashed-32
[pretested-integration-plugin__demo-job-squashed-strategy] $ git push origin :ready/feature-squashed-32
[PREINT] Done deleting development branch
Code Block
[PREINT] Preparing environment using Pretested Integration Plugin 2.2.3 (5f8d7) 
Checking out integration target branch master and pulling latest changes
[PREINT]  git checkout -B master origin/master
[pretested-integration-plugin__demo-job-squashed-strategy] $ git checkout -B master origin/master
[PREINT]  git pull origin master
[pretested-integration-plugin__demo-job-squashed-strategy] $ git pull origin master
Preparing to merge changes in commit 4f0f6c07291d1b936918fa79823e523ce6fb0aab to integration branch master(94c9c678b20c6486df218e356887f64f76c01227)
[PREINT]  git merge --squash origin/ready/feature-squashed-31
[pretested-integration-plugin__demo-job-squashed-strategy] $ git merge --squash origin/ready/feature-squashed-31
[PREINT]  git commit --no-edit
[pretested-integration-plugin__demo-job-squashed-strategy] $ git commit --no-edit
Commit message:
Demo commit message for Pretested Integration:

This is a longer commit message about what this commit is about.

We use this commit to illustrate the Prested Integration Plugin commit messages, based on their strategies. There are two demo jobs, one for each strategy and a job that does two commits, one on two different branches to be picked up as ready branches.

[pretested-integration-plugin__demo-job-squashed-strategy] $ /bin/sh -xe /tmp/hudson666893911441445345.sh
+ echo Build and verification was successful
Build and verification was successful
Performing pre-verified post build steps
[PREINT-GIT] Commiting changes
[PREINT]  git push origin master
[pretested-integration-plugin__demo-job-squashed-strategy] $ git push origin master
[PREINT-GIT] Deleting development branch
[PREINT]  git push origin :ready/feature-squashed-31

Squashed demo job example #32

Squashed demo job example #31

Accumulated strategy - commit message

Version 2.3.0

Version 2.2.3

Image Removed

Image Removed

Squashed strategy - commit message

Version 2.3.0

Version 2.2.3

Image Removed

Image Removed

Manual building

In general you are not able to use 'Build now' with a pretested integration job configuration. The Pretested Integration Plugin is first in action when a "workspace" is handed over from the Git Plugin (or Multiple SCMs Plugin), and typically those will serve the last build revision again. If that succeeded last time, the revision is deleted after the integration and retrying the integration fails.

Some successful and failing cases using manual builds are:

  • If last build failed, thus the integration failed, for a non-persistent error (slave problem, licensing problem ...) rebuilding the job can succeed if no other build have been executed since last time.
  • Rebuilding after a successful build will typically fail, if the build is rebuilding the same revision again. That revision doesn't not exist as it is deleted after a successful integration in last build.
  • If you have done a job configuration change, and need to trigger the job to test the configuration you typically need to make a commit that triggers the job. Push a commit to a ready branch, or wait for one.
  • There is a work around, that often enables you to build manually: Make the job parametrized with BRANCH_TO_BUILD and use that variable in the 'branch specifier'. Make BRANCH_TO_BUILD have the default ready-branch specifier, so if not given the job works as if there were no parameters. If you now build the job manually, you can type in a branch to build.

You are welcome to contribute with ideas and use-cases for manual build and support for it on the roadmap in the Trello board.

Using multiple repository configurations

The plugin is designed to work on only one repository - as in you can only integrate on one repository pr. Jenkins job, but your Jenkins job can be used with multiple repositories for eg. checking out several repositories into a given folder structure you need for building the software. Though we consider this a work-around for not having the right dependency management, it can be done. You have the choice of using the Git Plugin or the Multiple SCMs Plugin, but need to follow the configuration examples below.

Requirements if using multiple repository jobs

Every repository should be explicitly and uniquely named* in the git repository configuration under 'Advanced'. Then use this as integration repository in the prested integration configuration

Example with multiple git repositories

Image Removed Image Removed

  • The two repositories 'capital-letters' and 'numbers' are checked out to the same workspace.
  • 'numbers' are the repository that is being integrated, so the branch specifier will typically match that patter ('capital-letters' might just be needed for building)
  • The pretested integration configuration now explicitly states that the 'numbers' repository is the integration repository.
  • Also remember to add the two additional behaviours to ensure a clean work space and that old deleted branches are cleaned

Basically the same setup needs to be applied if using the Multiple SCMs plugin, but you can benefit from additional behaviours like checking each git repository out to a subdirectory if needed. Still every git repository must be explicitly and uniquely named.

Acknowledgement

Code contributions were initially made by Computer Science students at University of Copenhagen as part of a study project

Ronni Elken Lindsgaard
Alexander Winther Uldall
Esben Skaarup
Andreas Frisch

Issues

Jira Issues
columnstype;key;summary
width85%
anonymoustrue
titleOpen issues
urlhttp://issues.jenkins-ci.org/sr/jira.issueviews:searchrequest-xml/temp/SearchRequest.xml?jqlQuery=project+%3D+JENKINS+AND+status+in+%28Open%2C+%22In+Progress%22%2C+Reopened%29+AND+component+%3D+%27pretested-integration-plugin%27

Changes

(unreleased) 2.3.0

Available as snapshot artifact in our Jenkins pipeline

}
}

Multibranch Pipeline Project

When configuring the plugin with multibranch projects the configuration is a little different. When you create your Multibranch Project you do not put the Pretested Integration extension in the SCM configuration as part of the branch source. Instead you need to configure the pipeline to ignore default checkout and perform the checkout in a step, where you do add the pretestedIntegration extension. Like so:

Code Block
languagegroovy
titleMultibranch Declarative Example
linenumberstrue
pipeline {
   agent any
   options { skipDefaultCheckout() }
   stages {
       stage("checkout") {
           steps {
		checkout([$class: 'GitSCM', branches: [[name: '*/ready/**']], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'CleanBeforeCheckout'], pretestedIntegration(gitIntegrationStrategy: squash(), integrationBranch: 'master', repoName: 'origin')], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'pipCredentials', url: 'https://your.repo.com.git']]])
           }
       }
       stage("publish") {
           steps {
               pretestedIntegrationPublisher()
           }
       }
   }
}

Usage scenarios

As a developer using CLI

See this link:  Link to usage with the CLI

As a developer using Eclipse

Follwo the guide Using Eclipse

Issues

See Github issues for current backlog and know issues.

Changes

Version 3.1.0

  • Fixed an issue that caused build to continue, even though integration failed in the SCM step.
  • Added option to shorten the merge commit message for the Accumulated commit strategy. 
  • Minor correction to output in console.

Version 3.0.1

  • Identical to 3.0.0 we just changed version number to not include git SHA as it breaks compatibility with Jenkins Docker install-plugins.sh script and is not fully semver compliant.

Version 3.0.0 incl. betas - Not backwards compatible!

The overall changes in 3.0.0 all have to do with making the plugin pipeline compatible. No changes to the behaviour of the plugin are in this new release.

  • Scripted pipeline support

  • Declarative pipeline support

  • Optional post build step, merge result is now optional

  • Can be used with Matrix jobs since publisher is now optional.

  • Deprecated use of MultiSCM Plugin

Version 2.4.1

  • Made a clearer error message when the plugin fails to push empty commits. (#15

Version 2.4.0

  • Added Credentials plugin support by replacing remaining CLI calls with GitClient implementations. (issue #29104)
  • No longer refuses to integrate branches whose names contain 'master'. (Still blocks integration of 'master'.) (issue #31138)
  • No longer marks builds with SUCCESS if the Pretested Integration step fails. (issue #30465)
  • Fixed post-install plugin description. (issue #31388)
  • Plugin version is now printed to console. (issue #31139)

Version 2.3.4

  • Single commits are fast-forward merged when possible. (issue #30891)

Version 2.3.3

Version 2.3.2

Version 2.3.1

  • Squash integration strategy no longer replaces the message of single commits. (issue #30603)

Version 2.3.0

  • More logging and information in general for better debugging and understanding why builds fail. Part of feature implementation and re-factoring for JENKINS-27690, JENKINS-28590
  • Output to build console is extended and streamlines between the two different integration strategies (JENKINS-28590)
  • JENKINS-28590: Author of the integration commit is the author of the last commit on the development branch (instead of always the build user).
  • JENKINS-28596: It is possible for the accumulated to use a custom integration branch, a bug was fixed in this area.
  • Test were written to check commit message with quotes will not fail integration ( JENKINS-27662). There are still issue though, reported in unfixed issue JENKINS-28640
  • Changed test strategy toward static git repositories, that are added as test resources for the functional tests
  • JENKINS-27697: Improvements around releasing files for test repositories, so functional tests for the plugin will also run on Windows
  • JENKINS-29369: Changed accumulated commit message date strings to be English locale. (Not fixed is that timezone still local - see JENKINS-29377 and discussion here: https://trello.com/c/aY5d8Sxd/130-jenkins-29377-date-formatting-should-be-utc-in-accumulated-msg)
  • JENKINS-28640: Quotationmarks in commit message is replaced with single plings, as using quotationmarks lead to merge failure as they were not escaped properly.

Version 2.2.3

  • JENKINS-27516 Plugin hangs - reproduced with failed earlier build. A regression problem, related to never Jenkins cores and that the plugin used semaphores. Problem was seen, by the plugin prints the version number in the job console and then the job hangs.

Version 2.2.1

  • JENKINS-26568 New accumulated commit message. Almost identical to what you get from squash commit, thus it have much more traceability by including the commit messages from all included commits.

Version 2.2.0

Version 2.1.2

  • Implemented logging tracing

Version 2.1.1

Version 2.1.0

  • Protected master branch (Plugin tries to delete origin/master JENKINS-24286)
  • Re-using last commit message in accumulated strategy (Improve commit message JENKINS-24285)
  • Removed the "origin" from the description (JENKINS-24284)
  • When squashing commits, now using author from tip of branch (JENKINS-24443)
  • Additional tests added as well

Version 2.0

  • Git integration is now supported

Version 1.1

  • Dependency of Mercurial plugin set to 1.39 due to previous failure to trigger on merge commits
  • Removed UI elements that should not have been there

Version 1.0

  • Release of the first stable versionIversion