Currently running build is not stopped by new commit/s for the same PR

[oviupstack]

• I am not able to fix the problem myself and send a pull request instead of an issue.
• There is no existing issue regarding the same topic

• Plugin Version: 2.2.1
• Jenkins Version: 2.190.3
• Jenkins Job Type: Freestyle
• Triggered via: Bitbucket Cloud

Expected Behavior

While an existing build is in progress for the project, triggered by this plugin because of a PR update (new commit) or PR create events, if I submit another commit and bitbucket sends an PR update event, the ongoing build should be cancelled/stopped and a new one should start that will pick the new revision.

Actual Behavior

Current build it is not stopped, it keeps on going; the new build for the new commit is not triggered even though "Execute concurrent builds if necessary" is checked, I understand this is not a setting that belongs to this plugin... however it makes sense to work.

Steps to Reproduce

Provide an unambiguous set of steps to reproduce this bug

1. have a project that is triggered on the PR update and create events
2. create a PR, build will start
3. wait 5 min and then commit changes to the same PR
4. observe how the second commit it is not stopping the current build and it is not triggering another build

Context

This is affecting resource consumption, time consumption, and it can mislead cause it finishing the old build and not builds the second. thus leaving with impression build is successful on the last commit.

Bitbucket payload

usual update PR event. it is quite long,I can provide it if really needed it.

Jenkins Job configuration

we access bitbucket through stored credentials in jenkins
building branch origin/feature/* but it is reproing with simpler filters like origin/development

[ghost]

This was never a feature of Jenkins or Bitbucket plugin at any point. You can workaround it by using this code in your Jenkinsfile:

// Abort older builds if new is started
def buildNumber = env.BUILD_NUMBER as int
if (buildNumber > 1) milestone(buildNumber - 1)
milestone(buildNumber)

It requires concurrent builds to be allowed.

[clutcher]

More flexible solution. It iterates via all queued jobs and all running jobs and will abort all jobs, which were triggered by BPPR plugin for same branch.

To use it just add at the top of Jenkinsfile before pipeline block:

@NonCPS
boolean isTriggeredFromPR(runnable, branchName) {
    def runTaskCauses = runnable.getCauses()
    for (cause in runTaskCauses) {
        if (cause instanceof io.jenkins.plugins.bitbucketpushandpullrequest.cause.BitBucketPPRTriggerCause) {
            def prAction = cause.getAction()
            if (prAction.getSourceBranch() == branchName) {
                return true
            }
        }
    }
    return false
}

@NonCPS
def abortSimilarJobs() {
    println("Abort queued jobs for same branch")

    def BRANCH_FOR_JOB_ABORTING
    if (env.BITBUCKET_SOURCE_BRANCH) {
        BRANCH_FOR_JOB_ABORTING = env.BITBUCKET_SOURCE_BRANCH
    } else {
        BRANCH_FOR_JOB_ABORTING = env.JENKINS_JOB_CUSTOM_BRANCH
    }

    if (BRANCH_FOR_JOB_ABORTING) {
        println("Identify jobs for aborting by branch '${BRANCH_FOR_JOB_ABORTING}'")

        println("Clean up queue")
        def taskQueue = Jenkins.instance.queue
        taskQueue.items.each { queueItem ->
            def placeholderTask = queueItem.task
            // To filter by task type put here if placeholderTask.getOwnerTask().getName() == Auto_CI etc
            try {
                def run = placeholderTask.run()
                if (run && isTriggeredFromPR(run, BRANCH_FOR_JOB_ABORTING)) {
                    println("Cancelling " + placeholderTask.getName())
                    taskQueue.cancel(placeholderTask)
                }
            } catch (Exception e) {
                println("Not executable job found")
            }
        }

        println("Clean up running build")
        Jenkins.instance.computers.each { computer ->
            computer.getExecutors().each { executor ->
                if (executor.isBusy()) {
                    def executableWrapper = executor.getCurrentExecutable()
                    def placeholderTask = executableWrapper.getParent()
                    try {
                        def run = placeholderTask.run()
                        if (run && isTriggeredFromPR(run, BRANCH_FOR_JOB_ABORTING)) {
                            println("Cancelling running " + placeholderTask.getName())
                            executor.interrupt(Result.ABORTED, new CauseOfInterruption.UserInterruption("Interrupted by PR update"))
                        }
                    } catch (Exception e) {
                        println("Executing job already finished.")
                    }
                }
            }
        }
    }

    println("Finish job aborting")
}

// Execute before scheduling on execution
abortSimilarJobs()

Suppose this script could be simplified with jenkins milestones after jenkinsci/pipeline-milestone-step-plugin#17 would be merged and released.

[jtnord]

use properties([disableConcurrentBuilds(abortPrevious: true)]) rather than any similar hacks if you only want the latest run for a given branch/pr job.
jenkinsci/workflow-job-plugin#200

[clutcher]

@jtnord Thanks. I'll check if that works for my use case.