• get build
  • get WorkflowRun by build number
    • get current build actions
  • get build details
    • setup next build number
  • NODE_NAME and worksapce path
  • build cause
    • trigger cause
    • get build cause
    • get builds cause within 24 hours
    • details on Cause.UserIdCause
    • GerritCause
  • abort cause
    • builds aborted by timeout
    • abort by userId CauseOfInterruption.UserInterruption
    • get all abort causes
  • build log
    • get console output
    • check whether if log kept
    • check last N logs
  • build parameters
    • get build parameters
    • get builds parameters in Jenkinsfile
    • filter expected parameters and values
    • get wanted parameter values in builds
    • get only String type parameters
    • retrieving parameters and triggering another build
    • get queue jobs parameters
  • build changesets
    • code clone via DSL
  • SCM info
    • get repo url
  • build time
    • get started build time
    • sort last build
    • sort all buildable jobs
• list builds
  • last N builds
    • list last built N jobs
    • list last N builds
  • running builds
    • list all running builds via pattern
    • list builds running more than 24 hours via executor
    • list builds running more than 24 hours via pattern
  • via job pattern
    • list all builds byTimestamp within 24 hours
    • get last 24 hours failure builds
    • get last 24 hours failure builds in Map structure
  • via results
    • get all builds result percentage
    • get builds result percentage ( within 24 hours )
    • get builds result data range
    • get builds result and percentage in data range
• stop builds
  • abort single build
  • abort previous running builds by params condition
  • stop all queue and running jobs
  • stop all running builds via pattern
  • stop all running builds started in 24 hours
  • list all queue tasks and blocked reason
• remove builds
  • delete multiple builds

[!TIP|label:references:]

• currentBuild.class == Class RunWrapper
• currentBuild.rawBuild.class == jenkins.model.Jenkins.instance.getItemByFullName(String).getBuildByNumber(int).class == Class WorkflowRun

[!TIP|style:flat|label:get builds|icon:fa fa-bullhorn]

• inherited from hudson.model.Job :
  • WorkflowJob.getBuilds() : [marslo/sandbox #2, marslo/sandbox #1]
  • WorkflowJob.getBuildsAsMap() : [2:marslo/sandbox #2, 1:marslo/sandbox #1]
  • WorkflowJob.getLastFailedBuild() : get last failed build
  • WorkflowJob.getLastStableBuild() : get last stable build
  • WorkflowJob.getLastSuccessfulBuild() : get last successful build
  • WorkflowJob.getLastUnstableBuild() : get last unstalbe build
  • WorkflowJob.getLastUnsuccessfulBuild() : get last unsuccessful build
  • WorkflowJob.getLastCompletedBuild() : get last completed only build
• from org.jenkinsci.plugins.workflow.job.WorkflowJob :
  • WorkflowJob.getBuildByNumber(int n) : get specific build by number
  • WorkflowJob.getFirstBuild() : get first build
  • WorkflowJob.getLastBuild() : get last build
  • WorkflowJob.getNearestBuild(int n) : gets the youngest build #m that satisfies n<=m.
  • WorkflowJob.getNearestOldBuild(int n) : gets the latest build #m that satisfies m<=n.

get build

[!NOTE|label:references:]

• How to get Jenkins build job details?

get WorkflowRun by build number

final String JOB_NAME  = 'marslo/sandbox'
final int BUILD_NUMBER = 6458

def build = jenkins.model.Jenkins.instance
                   .getItemByFullName( JOB_NAME )
                   .getBuildByNumber( BUILD_NUMBER )

get current build actions

currentBuild.rawBuild.actions.collect { it.getClass() }.join('\n')

• result

  class hudson.model.CauseAction
  class hudson.plugins.jobConfigHistory.JobConfigBadgeAction
  class jenkins.metrics.impl.TimeInQueueAction
  class org.jenkinsci.plugins.buildtriggerbadge.BuildTriggerBadgeAction
  class org.jenkinsci.plugins.workflow.libs.LibrariesAction
  class com.cloudbees.plugins.credentials.builds.CredentialsParameterBinder
  class hudson.plugins.git.util.BuildData
  class io.jenkins.plugins.forensics.git.reference.GitCommitsRecord
  class hudson.plugins.ansicolor.action.ColorizedAction
  class hudson.plugins.ansicolor.action.ColorizedAction
  class org.jenkinsci.plugins.workflow.cps.EnvActionImpl
  

get build details

import org.jenkinsci.plugins.workflow.job.WorkflowJob
import hudson.util.RunList

WorkflowJob job = jenkins.model.Jenkins.instance.getItemByFullName( '/marslo/sandbox/test' )
RunList runList = job.getBuilds()

println """
                  all builds : ${job.getBuildsAsMap().collect{ k, v -> k }}
                build exists : ${job.getBuilds().collect { it.id }.contains( 25.toString() )}

             completedOnly() : ${runList.completedOnly().collect{ it.id }}
               failureOnly() : ${runList.failureOnly().collect{ it.id }}
              getLastBuild() : ${runList.getLastBuild()}
             getFirstBuild() : ${runList.getFirstBuild()}

     getLastCompletedBuild() : ${job.getLastCompletedBuild()}
        getLastFailedBuild() : ${job.getLastFailedBuild()}
        getLastStableBuild() : ${job.getLastStableBuild()}
    getLastSuccessfulBuild() : ${job.getLastSuccessfulBuild()}
      getLastUnstableBuild() : ${job.getLastUnstableBuild()}
  getLastUnsuccessfulBuild() : ${job.getLastUnsuccessfulBuild()}
                 isInQueue() : ${job.isInQueue()}
           getActions.causes : ${runList.collect{ run -> run.id + ': ' + run.getActions( jenkins.model.InterruptedBuildAction.class ).causes.flatten().collect{ it.class.simpleName } }}
"""

• result:

                    all builds : [42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
                  build exists : true
  
               completedOnly() : [42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
                 failureOnly() : [42, 41, 40, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
                getLastBuild() : marslo/abort #42
               getFirstBuild() : marslo/abort #1
  
       getLastCompletedBuild() : marslo/abort #42
          getLastFailedBuild() : marslo/abort #32
          getLastStableBuild() : marslo/abort #39
      getLastSuccessfulBuild() : marslo/abort #39
        getLastUnstableBuild() : null
    getLastUnsuccessfulBuild() : marslo/abort #42
                   isInQueue() : false
             getActions.causes : [42: [ExceededTimeout], 41: [ExceededTimeout], 40: [ExceededTimeout], 36: [ExceededTimeout], 35: [ExceededTimeout], 34: [ExceededTimeout], 33: [ExceededTimeout], 32: [], 31: [], 30: [ExceededTimeout], 29: [], 28: [], 27: [], 26: [], 24: [], 23: [], 22: [ExceededTimeout], 21: [], 20: [], 19: [ExceededTimeout], 18: [ExceededTimeout], 17: [], 16: [], 15: [], 14: [], 13: [], 12: [], 11: [], 10: [ExceededTimeout], 9: [ExceededTimeout], 8: [UserInterruption], 7: [ExceededTimeout], 6: [UserInterruption], 5: [UserInterruption], 4: [ExceededTimeout], 3: [ExceededTimeout], 2: [UserInterruption], 1: [ExceededTimeout]]
  

get culprits

println build.getCulprits()

setup next build number

jenkins.model.Jenkins.instance
       .getItemByFullName( '/path/to/job' )
       .updateNextBuildNumber( n )

NODE_NAME and worksapce path

[!NOTE|label:references:]

• getNodeWsUrl - Get step id in Jenkins Pipeline for linking to BlueOcean or Pipeline Steps view (flowGraphTable)

import org.jenkinsci.plugins.workflow.support.actions.WorkspaceRunAction

jenkins.model.Jenkins
             .instance
             .getItemByFullName( JOB_NAME )
             .getBuildByNumber( BUILD_NUMBER )
             .getAction(WorkspaceRunAction.class).getActions().each {
                println "${it.node}: ${it.path}"
             }

build cause

trigger cause

import org.jenkinsci.plugins.parameterizedscheduler.ParameterizedTimerTriggerCause
import hudson.model.Cause.UpstreamCause
import org.jenkinsci.plugins.workflow.cps.replay.ReplayCause
import com.sonyericsson.rebuild.RebuildCause
import hudson.model.Cause.UserIdCause
import com.sonyericsson.hudson.plugins.gerrit.trigger.hudsontrigger.GerritCause
import org.jenkinsci.plugins.workflow.job.WorkflowJob
import hudson.util.RunList

WorkflowJob job = jenkins.model.Jenkins.instance.getItemByFullName( '/path/to/job' )
RunList builds  = job.getBuilds()

builds.each { build ->
  println build.number
  println build.getCauses()
  println build.getCauses().collect { it.getClass().getCanonicalName() }
  println "byUser        : ${build.getCause( UserIdCause.class  ) && true        }"
  println "byRebuild     : ${build.getCause( RebuildCause.class ) && true        }"
  println "byReplay      : ${build.getCause( ReplayCause.class  ) && true        }"
  println "byUpstream    : ${build.getCause( Cause.UpstreamCause.class ) && true }"
  println "byGerritCause : ${build.getCause( GerritCause.class ) && true         }"
}

"DONE"

get build cause

List<String> projects = [ 'project-1', 'project-2', 'project-n' ]
jeniins.model.jenkins.model.Jenkins.instance.getAllItems( Job.class ).findAll {
  projects.any { p -> it.fullName.startsWith(p) }
}.each {
  println it.name + "\t -> " + it.fullName + "\t ~> " +
          ( it.getLastBuild()?.getCauses()?.collect { it.getClass().getCanonicalName() }?.join(', ') ?: 'no build' )
}

"DONE"

• result

  user-trigger -> marslo/user-trigger ~> hudson.model.Cause.UserIdCause
  sandbox      -> marslo/sandbox      ~> hudson.model.Cause.UserIdCause, org.jenkinsci.plugins.workflow.cps.replay.ReplayCause
  whitebox     -> marslo/whitebox     ~> org.jenkinsci.plugins.workflow.support.steps.build.BuildUpstreamCause, hudson.model.Cause.UserIdCause, com.sonyericsson.rebuild.RebuildCause
  replay       -> marslo/reply        ~> org.jenkinsci.plugins.workflow.cps.replay.ReplayCause, hudson.model.Cause.UserIdCause, com.sonyericsson.rebuild.RebuildCause
  no-build     -> marslo/no-build     ~> no build
  rebuild      -> marslo/rebuild      ~> org.jenkinsci.plugins.workflow.cps.replay.ReplayCause, hudson.model.Cause.UserIdCause, com.sonyericsson.rebuild.RebuildCause
  upstream     -> marslo/upstream     ~> org.jenkinsci.plugins.workflow.support.steps.build.BuildUpstreamCause
  Result: DONE
  

• or

  List<String> projects = [ 'project-1', 'project-2', 'project-n' ]
  jenkins.model.Jenkins.instance.getAllItems( Job.class ).findAll {
    projects.any { p -> it.fullName.startsWith(p) }
  }.each {
    println it.name + "\t -> " +
            it.fullName + " :\n\t\t" +
            (
              it.getLastBuild()?.getCauses()?.collect { it.getClass().getCanonicalName() }.join('\n\t\t') ?: 'no-builds'
            )
  }
  "DONE"
  

get builds cause within 24 hours

import hudson.model.Job
import hudson.model.Run
import java.util.Calendar
import jenkins.model.Jenkins

final List<String> PROJECTS = [ 'project-1' ]
final long BENCH_MARK       = 1*24*60*60*1000
final Calendar RIGHT_NOW    = Calendar.getInstance()

jenkins.model.Jenkins.instance.getAllItems(Job.class).findAll { Job job ->
  PROJECTS.any { job.fullName.startsWith(it) }
}.collectEntries { Job job ->
  [
    ( job.fullName ) : job.builds.findAll { Run run ->
                         ( RIGHT_NOW.getTimeInMillis() - run.getStartTimeInMillis() ) <= BENCH_MARK
                       }.collectEntries { Run run ->
                         [
                           (run.id) : run.getCauses()?.collect { it.getClass().getSimpleName() }?.join(' -> ')
                         ]
                       }

  ]
}.collectEntries { k, v ->
  [
    (k) : v.groupBy( {it.value} )
           .collectEntries{ x, y -> [ (x) : y.keySet() ] }
  ]
}.each{ k, v ->
  println ">> ${k} : ${v.values().flatten().size()}"
  println v.collect { "\t${it.key} : \n\t\t${it.value.join('\n\t\t')}" }.join('\n')
}

"DONE"

• result:

  >> project-1 : 4
     BuildUpstreamCause :
       122
       123
     BuildUpstreamCause ->  UserIdCause ->  RebuildCause :
       124
     UserIdCause ->  ReplayCause :
       125
  Result: DONE
  

details on Cause.UserIdCause

jenkins.model.Jenkins.instance
       .getItemByFullName( JOB_NAME )
       .getBuildByNumber( JOB_NUMBER )
       .getActions( hudson.model.CauseAction.class )
       .causes
       .flatten()
       .each { c ->
          println c.userId
          println c.getUserName()
          println c.getShortDescription()
          println c.getUserUrl()
       }

GerritCause

import org.jenkinsci.plugins.workflow.job.WorkflowJob
import hudson.util.RunList
import com.sonyericsson.hudson.plugins.gerrit.trigger.hudsontrigger.GerritCause
import com.sonyericsson.hudson.plugins.gerrit.trigger.hudsontrigger.GerritUserCause
import com.sonyericsson.hudson.plugins.gerrit.trigger.hudsontrigger.GerritManualCause
import com.sonymobile.tools.gerrit.gerritevents.dto.events.CommentAdded
import com.sonymobile.tools.gerrit.gerritevents.dto.events.RefUpdated
import com.sonymobile.tools.gerrit.gerritevents.dto.events.PatchsetCreated

WorkflowJob job = jenkins.model.Jenkins.instance.getItemByFullName( '/path/to/pipeline' )
RunList builds  = job.getBuilds()

builds.each { build ->
  if ( build.getCause( GerritCause.class ) && true ) {
    println build.number
    println "context           : ${build.getCause( GerritCause.class ).getContext()}"
    println "  build number    : ${build.getCause( GerritCause.class ).getContext().getThisBuild().getBuildNumber().toString()}"
    println "  project name    : ${build.getCause( GerritCause.class ).getContext().getThisBuild().getProjectId()}"
    println "description       : ${build.getCause( GerritCause.class ).getShortDescription()}"
    println "url               : ${build.getCause( GerritCause.class ).getUrl()}"
    println "events            : ${build.getCause( GerritCause.class ).getEvent().getClass()}"
    println "  byCommentAdded  : " +
            ( build.getCause(GerritCause.class).getEvent() instanceof CommentAdded ).toString()
    println "  byRefUpdated    : " +
            ( build.getCause(GerritCause.class).getEvent() instanceof RefUpdated ).toString()
    println "  byPathUpdated   : " +
            ( build.getCause(GerritCause.class).getEvent() instanceof PatchsetCreated).toString()
    println "  server hostname : " +
            build.getCause( GerritCause.class ).getEvent().getProvider().host
    println "  server port     : " +
            build.getCause( GerritCause.class ).getEvent().getProvider().port
    println "  server version  : " +
            build.getCause( GerritCause.class ).getEvent().getProvider().version
    println '.'*10
    println "userCause?        : ${build.getCause( GerritUserCause.class ) && true}"
    if (build.getCause( GerritUserCause.class ) && true) {
      println "  comments        : " +
              build.getCause( GerritUserCause.class )?.getEvent().comment
      println "  approvals       : " +
              build.getCause( GerritUserCause.class )?.getEvent().approvals
      println "  change          : " +
              build.getCause( GerritUserCause.class )?.getEvent().change
      println "  usernmae        : " +
              build.getCause( GerritUserCause.class )?.getUserName()
      println "  description     : " +
              build.getCause( GerritUserCause.class )?.getShortGerritDescription()
      println "  changer account : " +
              build.getCause( GerritUserCause.class )?.getEvent().getAccount().name
      println "  changer email   : " +
              build.getCause( GerritUserCause.class )?.getEvent().getAccount().email
    }
    println '.'*10
    println "manualCause?      : ${build.getCause( GerritManualCause.class ) && true}"
    println '~'*30
  }
}

"DONE"

  10121
  context           : com.sonyericsson.hudson.plugins.gerrit.trigger.hudsontrigger.data.TriggerContext@6fbdc2a5
    build number    : 10121
    project name    : /path/to/project
  description       : Retriggered by user marslo for Gerrit: https://gerrit.sample.com/c/my/project/+/72667
  url               : https://gerrit.sample.com/c/my/project/+/72667
  events            : class com.sonymobile.tools.gerrit.gerritevents.dto.events.CommentAdded
    byCommentAdded  : true
    byRefUpdated    : false
    byPathUpdated   : false
    server hostname : gerrit.sample.com
    server port     : 29418
    server version  : 2.16.27-RP-1.10.1.1
  ..........
  userCause?        : true
    comments        : Patch Set 104: Code-Review+2
    approvals       : [Approval: Verified 0, Approval: Code-Review 2]
    change          : Change-Id for #72667: I68e47b094e142a63cec7c698094320d79f5350f8
    usernmae        : marslo
    description     : Retriggered by user marslo for Gerrit: https://gerrit.sample.com/c/my/project/+/72667
    changer account : Marslo Jiao
    changer email   : marslo@gmail.com
  ..........
  manualCause?      : false
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  10120
  context           : com.sonyericsson.hudson.plugins.gerrit.trigger.hudsontrigger.data.TriggerContext@26ab2c12
    build number    : 10120
    project name    : /path/to/project
  description       : Triggered by Gerrit: https://gerrit.sample.com/c/my/project/+/123069
  url               : https://gerrit.sample.com/c/my/project/+/123069
  events            : class com.sonymobile.tools.gerrit.gerritevents.dto.events.CommentAdded
    byCommentAdded  : true
    byRefUpdated    : false
    byPathUpdated   : false
    server hostname : gerrit.sample.com
    server port     : 29418
    server version  : 2.16.27-RP-1.10.1.1
  ..........
  userCause?        : false
  ..........
  manualCause?      : false
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

abort cause

jenkins.model.Jenkins.instance
       .getItemByFullName( JOB_NAME )
       .getBuildByNumber( BUILD_NUMBER )
       .getActions( jenkins.model.InterruptedBuildAction.class )
       .causes
       .flatten()

builds aborted by timeout

import org.jenkinsci.plugins.workflow.steps.TimeoutStepExecution

jenkins.model.Jenkins.instance
       .getItemByFullName( JOB_NAME )
       .getBuildByNumber( BUILD_NUMBER )
       .getActions( jenkins.model.InterruptedBuildAction.class )
       .causes
       .flatten()
       .any { it instanceof TimeoutStepExecution.ExceededTimeout }

• or

  import org.jenkinsci.plugins.workflow.steps.TimeoutStepExecution
  import org.jenkinsci.plugins.workflow.job.WorkflowJob
  
  WorkflowJob job = jenkins.model.Jenkins.instance.getItemByFullName( JOB_NAME )
  job.builds.findAll { Run run ->
    BUILD_NUMBER.toString() == run.id
  }.collect { Run run -> run.getActions( jenkins.model.InterruptedBuildAction.class )
                            .causes
                            .flatten()
                            .any { it instanceof TimeoutStepExecution.ExceededTimeout }
  }
  

abort by userId CauseOfInterruption.UserInterruption

import org.jenkinsci.plugins.workflow.support.steps.build.BuildTriggerCancelledCause
import jenkins.model.CauseOfInterruption

jenkins.model.Jenkins.instance
       .getItemByFullName( JOB_NAME )
       .getBuildByNumber( BUILD_NUMBER )
       .getActions( jenkins.model.InterruptedBuildAction.class )
       .causes
       .flatten()
       .any { c ->
                  [ CauseOfInterruption.UserInterruption, BuildTriggerCancelledCause ].any {
                    it.isAssignableFrom( c.getClass() )
                  }
            }

• get user details

  import jenkins.model.CauseOfInterruption
  
  jenkins.model.Jenkins.instance
         .getItemByFullName( '/marslo/sandbox/abort' )
         .getBuildByNumber(159)
         .getActions( jenkins.model.InterruptedBuildAction.class )
         .causes
         .flatten()
         .findAll { c -> [ CauseOfInterruption.UserInterruption ].any { it.isAssignableFrom(c.getClass()) } }
         .each { c ->
           User user = c.user
           println c.getShortDescription()
           println "${user.fullName} : ${user.absoluteUrl}"
           currentBuild.description = 'ABORTED by user : <a href="${user.absoluteUrl}">' +
                                      "${user.displayName} [ ${user.id} ]</a>"
           currentBuild.result = 'NOT_BUILT'
         }
  

get all abort causes

import org.jenkinsci.plugins.workflow.job.WorkflowJob

WorkflowJob job = jenkins.model.Jenkins.instance.getItemByFullName( JOB_NAME )
job.builds.findAll { Run run ->
  run.getActions( jenkins.model.InterruptedBuildAction.class ).causes
}.collect{ Run run ->
  List c = run.getActions( jenkins.model.InterruptedBuildAction.class ).causes
  "#${run.id} : ${c.flatten().collect{ it.class.simpleName }.first()}"
}.join('\n')

• result:

  #42 : ExceededTimeout
  #41 : ExceededTimeout
  #40 : ExceededTimeout
  #36 : ExceededTimeout
  #35 : ExceededTimeout
  #34 : ExceededTimeout
  #33 : ExceededTimeout
  #30 : ExceededTimeout
  #22 : ExceededTimeout
  #19 : ExceededTimeout
  #18 : ExceededTimeout
  #10 : ExceededTimeout
  #9 : ExceededTimeout
  #8 : UserInterruption
  #7 : ExceededTimeout
  #6 : UserInterruption
  #5 : UserInterruption
  #4 : ExceededTimeout
  #3 : ExceededTimeout
  #2 : UserInterruption
  #1 : ExceededTimeout
  

build log

get console output

jenkins.model.Jenkins.instance
       .getItemByFullName( JOB_NAME )
       .getBuildByNumber( BUILD_NUMBER )
       .logFile
       .text

check whether if log kept

import org.jenkinsci.plugins.workflow.job.WorkflowJob

workflowJob job = jenkins.model.Jenkins.instance.getItemByFullName( '/sandbox/job' )
job.builds.findAll { Run run -> run.isKeepLog() }
          .collect { Run run -> run.id }

• list build number and start timestamp

  List<String> projects = [ 'project-1', 'project-2', 'project-n' ]
  
  jenkins.model.Jenkins.instance
         .getAllItems( Job.class )
         .findAll { projects.any { p -> it.fullName.startsWith(p) } }
         .findAll { job -> job.builds.any { Run run -> run.isKeepLog() } }
         .collectEntries {[
            ( it ) : it.builds.findAll { Run run -> run.isKeepLog() }
         ]}
         .each { k, v ->
           println '>> ' + k.fullName.padRight(35) + ': \n\t - ' +
             [
               v.id,
               v.collect{ new Date(it.startTimeInMillis).format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'") }
               // v.collect { groovy.time.TimeCategory.minus( new Date(), it.getTime() ) }
               // v.collect { it.getTime() }
             ].transpose()
              .collectEntries()
              .collect{ "${it.key.padRight(5)} : ${it.value}" }
              .join('\n\t - ')
         }
  
  "DONE"
  
  -- result --
  v.collect{ new Date(it.startTimeInMillis).format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'") } :
  >> marslo/sample
     - 454   : 2024-02-13T10:16:31.563Z
     - 36    : 2023-10-18T03:39:19.496Z
     - 32    : 2023-10-18T03:39:05.577Z
  
  v.collect { groovy.time.TimeCategory.minus( new Date(), it.getTime() ) } :
  >> marslo/sample
     - 454   : 1 days, 7 hours, 27 minutes, 13.394 seconds
     - 36    : 119 days, 15 hours, 4 minutes, 25.450 seconds
     - 32    : 119 days, 15 hours, 4 minutes, 39.369 seconds
  
  v.collect { it.getTime() }
  >> marslo/sample                          :
     - 454   : Tue Feb 13 10:16:31 PST 2024
     - 36    : Wed Oct 18 03:39:19 PDT 2023
     - 32    : Wed Oct 18 03:39:05 PDT 2023
  

• or

  List<String> projects = [ 'project-1', 'project-2', 'project-n' ]
  
  jenkins.model.Jenkins.instance
         .getAllItems( Job.class )
         .findAll { projects.any { p -> it.fullName.startsWith(p) } }
         .collectEntries {[
            ( it.fullName.toString() ) : it.builds.findAll { Run run -> run.isKeepLog() }
                                                  .collect { Run run -> run.id }
         ]}
         .findAll { it.value }
         .each { k, v ->
            println "~~> ${k}:\n\t#${v.join('\n\t#')}"
         }
  "DONE"
  

check last N logs

[!NOTE|label:original log:]

21:19:37  Running on Jenkins in /var/jenkins_home/workspace/marslo/desc
[Pipeline] {
[Pipeline] sh
21:19:37  + sleep 10
21:19:47
21:19:47  real  0m10.003s
21:19:47  user  0m0.000s
21:19:47  sys   0m0.003s
[Pipeline] }
[Pipeline] // node
[Pipeline] }
21:19:47
[Pipeline] // ansiColor
[Pipeline] }
[Pipeline] // timestamps
[Pipeline] End of Pipeline
Finished: SUCCESS

jenkins.model.Jenkins.instance.getItemByFullName( <JOB_PATTERN> )
                .getBuildByNumber( <BUILD_NUMBER> )
                .getLog( 30 )
                .find{ it.contains('real\t') }
                .split( '\t' )
                .last()
                .trim()

// Result: 0m10.003s

build parameters

get build parameters

def job = jenkins.model.Jenkins.instance.getItemByFullName( '/marlso/sandbox' )
job.builds.each { Run run ->
  String parameters = run?.getAction(ParametersAction.class)?.parameters?.collectEntries {
    [ it.name, it.value ]
  }.collect { k, v -> "\t\t${k}\t: ${v}" }
   .join('\n')
  println "#${run.id}: ${parameters}"
}

"DONE"

• result:

  #7:     id  : marslo
      gender  : female
  #6:     id  : marslo
      gender  : female
  #5:     id  : marslo
      gender  : female
  #4:     id  : marslo
      gender  : female
  #3:     name  : marslo
      gender  : female
  #2:     name  : marslo
      gender  : female
  #1:
  

• or via action instanceof ParametersAction

  def job = jenkins.model.Jenkins.instance.getItemByFullName( 'others-tests/sandbox' )
  job.getBuilds().each { Run build ->
    String parameters = build?.actions.find{ it instanceof ParametersAction }?.parameters?.collectEntries {
      [ it.name, it.value ]
    }.collect { k, v -> "\t\t${k}\t: ${v}" }
     .join('\n')
    println "#${build.getId()}: ${parameters}"
  }
  

• or by using Job Parameter Summary Plugin

  import hudson.model.*
  
  for( item in Hudson.instance.items ) {
    prop = item.getProperty( ParametersDefinitionProperty.class )
    if( prop ) {
      println( "--- Parameters for " + item.name + " ---" )
      for( param in prop.getParameterDefinitions() ) {
        try {
          println( param.name + " " + param.defaultValue )
        }
        catch( Exception e ) {
          println( param.name )
        }
      }
      println()
    }
  }
  

  • result:

    --- Parameters for GRA-00-UploadIntoClearCase ---
    ONCSDAP1_USER jdoe
    ONCSDAP1_PASSWORD
    GRA_ZIP_NAME GRA_Delivery_r.2.0.0_28-5_impl.zip
    GRA_RELEASE n.28
    
    --- Parameters for IN8-03-DeployXnetWebAppToRecette ---
    STOP_START_AS
    

get builds parameters in Jenkinsfile

[!TIP] running following snippet in Jenkinsfile

params.each { param ->
  println " ~~> '${param.key.trim()}' -> '${param.value}' "
}

• or : Jenkins : Parameterized System Groovy script

  def parameters = currentBuild.rawBuild?.getActions(ParametersAction.class)?.parameters
  parameters.each {
    println " ~~> ${it.name} -> ${it.value} -> ${it.description ?: ''} "
    println "-" * 20
  }
  

  • or

    def parameters = currentBuild.rawBuild?.actions.find{ it instanceof ParametersAction }?.parameters
    

filter expected parameters and values

[!NOTE|label:reference:]

• check if subMap belongs to the Map

import org.jenkinsci.plugins.workflow.job.WorkflowJob

Map pattern = [ gender : 'female' ]

WorkflowJob job = jenkins.model.Jenkins.instance.getItemByFullName( '/marslo/sandbox' )
job.builds.collectEntries { Run run ->
  [
    (run.id), run?.getAction(ParametersAction.class)?.parameters?.collectEntries {
                [ it.name, it.value ]
              }
  ]
}.findAll { it.value.entrySet().containsAll( pattern.entrySet() ) }
 .collect { "#${it.key}:\n\t${it.value.collect { v -> "${v.key}: ${v.value}" }.join('\n\t') }" }
 .join('\n')

get wanted parameter values in builds

[!TIP|label:reference:]

• Create a map in groovy having two collections - with keys and values

/**
 * to show all build parameters when the wanted params are found with nice format
**/
final String PARAM = 'id'
Map params         = [:]
Integer padding

def job = jenkins.model.Jenkins.instance.getItemByFullName( 'others-tests/sandbox' )
job.getBuilds().each { Run run ->
   params."${run.getId()}" = run?.getActions(ParametersAction.class)?.parameters?.collectEntries {
                               [ it.name , it.value ].transpose().collectEntries()
                             }
}
params  = params.findAll { it.value.get(PARAM) }

padding = params.values().collect { it.keySet() }.flatten().unique().collect { it.size() }.max()
params.collect {
         "\nbuild #${it.key}:\n" + it.value.collect { b -> "- ${b.key.padRight(padding + 1)}: ${b.value}" }.join('\n')
       }.join('\n')

• result

  build #7
  - id     : marslo
  - gender : female
  build #6
  - id     : marslo
  - gender : female
  build #5
  - id     : marslo
  - gender : female
  build #4
  - id     : marslo
  - gender : female
  

• or simple version

  final String PARAM = 'id'
  Map params = [:]
  
  def job = jenkins.model.Jenkins.instance.getItemByFullName( 'others-tests/sandbox' )
  job.getBuilds().each { Run build ->
    params."${build.getId()}" = build?.getActions(ParametersAction.class)?.parameters?.collectEntries {
                                  [ it.name , it.value ]
                                }
  }
  
  println params.collect { k , v ->
    "build #${k} ~~> ${v ? "${PARAM} : ${v.getOrDefault(PARAM, "No '${PARAM}' found")}" : 'No Params Found'}"
  }.join('\n')
  

  • result:

    build #7 ~~> id : marslo
    build #6 ~~> id : marslo
    build #5 ~~> id : marslo
    build #4 ~~> id : marslo
    build #3 ~~> id : No 'id' found
    build #2 ~~> id : No 'id' found
    build #1 ~~> No Params Found
    

get only String type parameters

Map params = build?.getAction( ParametersAction.class )
                   .parameters?.findAll{ it instanceof StringParameterValue }?.dump()

• or

  Map params = build?.getAction( ParametersAction.class )
                     .parameters?.findAll{ it instanceof StringParameterValue }?.collectEntries {
                       [ it.name, it.value ]
                     }
  

• or

  Map params = build?.actions
                     .find{ it instanceof ParametersAction }?.parameters?.findAll{ it instanceof StringParameterValue }?.dump()
  

retrieving parameters and triggering another build

import hudson.model.*
import hudson.AbortException
import hudson.console.HyperlinkNote
import java.util.concurrent.CancellationException

// Retrieve parameters of the current build
def foo = build.buildVariableResolver.resolve("FOO")
println "FOO=$foo"

// Start another job
def job = Hudson.instance.getJob('MyJobName')
def anotherBuild
try {
    def params = [
      new StringParameterValue('FOO', foo),
    ]
    def future = job.scheduleBuild2(0, new Cause.UpstreamCause(build), new ParametersAction(params))
    println "Waiting for the completion of " + HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName)
    anotherBuild = future.get()
} catch (CancellationException x) {
    throw new AbortException("${job.fullDisplayName} aborted.")
}
println HyperlinkNote.encodeTo('/' + anotherBuild.url, anotherBuild.fullDisplayName) + " completed. Result was " + anotherBuild.result

// Check that it succeeded
build.result = anotherBuild.result
if (anotherBuild.result != Result.SUCCESS && anotherBuild.result != Result.UNSTABLE) {
    // We abort this build right here and now.
    throw new AbortException("${anotherBuild.fullDisplayName} failed.")
}

// Do something with the output.
// On the contrary to Parameterized Trigger Plugin, you may now do something from that other build instance.
// Like the parsing the build log (see http://javadoc.jenkins-ci.org/hudson/model/FreeStyleBuild.html )
// You probably may also wish to update the current job's environment.
build.addAction(new ParametersAction(new StringParameterValue('BAR', '3')))

get queue jobs parameters

[!NOTE|label:refernece:]

• cg-soft/explore.groovy

def q = jenkins.model.Jenkins.instance.queue
q.items.each {
  println("${it.task.name}:")
  println("Parameters: ${it.params}")
}

build changesets

code clone via DSL

checkout([
  $class: 'GitSCM',
  branches: [[ name: 'refs/heads/sandbox' ]],
  browser: [
    $class: 'GitWeb',
    repoUrl: 'https://gerrit.sample.com/path/to/repo'
  ],
  userRemoteConfigs: [[
      credentialsId: 'SSHCredential',
      url: 'git://gerrit.sample.com/path/to/repo.git'
  ]]
])

jenkins.model.Jenkins.instance
       .getItemByFullName( '/marslo/up' )
       .getBuildByNumber( 195 )
       .changeSets
       .each {
         it.items.each { i ->
           println """
             \n-----------------------------\n
                      paths : ${i.paths}
              parent commit : ${i.parentCommit}
                   commitId : ${i.commitId} : ${i.revision}
                     author : ${i.author}
                 authorName : ${i.authorName}
                authorEmail : ${i.authorEmail}
              committerTime : ${i.committerTime}
                    message : ${i.msg}
                    repoUrl : ${it.browser?.repoUrl ?: ''}
             affected files :
               \t\t${i.affectedFiles.collect{ f -> f.editType.name + ' : ' + f.path }.join('\n\t\t\t\t')}
           """
         }
       }

• get changeSets to List<Map<String, String>>:

  def getChangeSets( String name, int nubmer ) {
    jenkins.model.Jenkins.instance
           .getItemByFullName( name )
           .getBuildByNumber( number )
           .changeSets
  }
  
  def changeSetsEntry( def changeSets ) {
    List<Map<String, String>> changeSetsEntry = []
    changeSets.collect { it.items.collect { i ->
      changeSetsEntry += [
        'parentCommit'  : i.parentCommit      ,
        'commitId'      : i.commitId          ,
        'revision'      : i.revision          ,
        'author'        : i.author.toString() ,
        'authorName'    : i.authorName        ,
        'authorEmail'   : i.authorEmail       ,
        'committerTime' : i.committerTime     ,
        'msgAnnotated'  : i.msg               ,
        'affectedFiles' : i.affectedFiles.collect{ f -> ['editType' : f.editType.name, 'path' : f.path ] }
      ]
    }}
    return changeSetsEntry
  }
  
  // testing
  List<Map<String, String>> totalChangeSets = []
  totalChangeSets += changeSetsEntry( getChangeSets('/path/to/pipeline', 123) )
  totalChangeSets += changeSetsEntry( getChangeSets('/path/to/pipeline', 456) )
  totalChangeSets.each {
    println """
      it.getClass()
      it.author
      it.commitId
    """
  }
  

SCM info

jenkins.model.Jenkins.instance
       .getItemByFullName( '/path/to/pipeline' )
       .getBuildByNumber( n )
       .SCMs
       .each {
         println """
           .......................
               repoUrl : ${it.userRemoteConfigs.url.join(',')}
               remotes : ${it.userRemoteConfigs.name.join(',')}
              branches : ${it.branches.join(',')}
           .......................
         """
       }

get repo url

def job = jenkins.model.Jenkins.instance
                 .getItemByFullName( '/path/to/pipeline' )
                 .getBuildByNumber( n )

job.changeSets
   .each {
     it.items.each { i ->
       println """
         \n-----------------------------\n
          repoUrl : ${ it.browser.repoUrl }
          repoUrl : ${ job.SCMs.collect { s -> s.browser?.repoUrl }.findAll().join() }
              url : ${ job.SCMs.collect { s -> s.browser?.url }.findAll().join() }
      ormalizeUrl : ${ job.SCMs.collect { s -> s.browser?.normalizeUrl } }
      absoluteUrl : ${ job.SCMs.collect { s -> s.browser?.getChangeSetLink(i) }.findAll().join() }
         commitId : ${i.commitId} : ${i.revision}
       """
     }
   }

• result:

  -----------------------------
  
            repoUrl : https://gerrit.sample.com/admin/repos/sandbox
            repoUrl : https://gerrit.sample.com/admin/repos/sandbox
                url : https://gerrit.sample.com/admin/repos/sandbox
        ormalizeUrl : [null, false]
        absoluteUrl : https://gerrit.sample.com/admin/repos/sandbox?a=commit&h=095e4470964ee8ca6ab50ceea7acf88094dc08d4
           commitId : 095e4470964ee8ca6ab50ceea7acf88094dc08d4 : 095e4470964ee8ca6ab50ceea7acf88094dc08d4
  

build time

[!TIP|label:references]

• Getting current tiestamp in inline pipeline script using pipeline plugin of hudson
• get Job && build by number for the Job and all related to time
• convert milliseconds to date-time format
• Date.format(String format)
  

final long NOW       = System.currentTimeMillis()
final int BENCH_MARK = 1*24*60*60*1000
println """
                               NOW : ${NOW}
                  NOW - BENCH_MARK : ${NOW - BENCH_MARK}
                Date(NOW).format() : ${new Date(NOW).format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")}
     Date(NOW-BENCH_MARK).format() : ${new Date(NOW - BENCH_MARK).format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")}
"""
 -- result --
                               NOW : 1619790803151
                  NOW - BENCH_MARK : 1619704403151
                Date(NOW).format() : 2021-04-30T06:53:23.151Z
     Date(NOW-BENCH_MARK).format() : 2021-04-29T06:53:23.151Z

import java.time.LocalDateTime
import java.time.LocalDate
import java.util.Calendar

final String JOB_PATTERN      = '<group>/<name>'
final LocalDateTime DATE_TIME = LocalDateTime.now()
final LocalDate DATE_TAG      = java.time.LocalDate.now()
final long CURRENT_TIME       = System.currentTimeMillis()
final long RIGHT_NOW          = Calendar.getInstance().getTimeInMillis()

println """
  >> current time :
        DATE_TIME : ${DATE_TIME}
         DATE_TAG : ${DATE_TAG}
     CURRENT_TIME : ${CURRENT_TIME}
        RIGHT_NOW : ${RIGHT_NOW}
"""

jenkins.model.Jenkins.instance.getAllItems( Job.class ).each { job ->
  if ( job.fullName.contains( JOB_PATTERN ) ) {
    def build = job.getLastBuild()
    println """
      >> ${job.getFullName()} : ${build.getId()} :
              build.getTimestampString() : ${build.getTimestampString()}
             build.getTimestampString2() : ${build.getTimestampString2()}
                         build.getTime() : ${build.getTime()}
                 build.startTimeInMillis : ${build.startTimeInMillis}
      build.startTimeInMillis.getClass() : ${build.startTimeInMillis.getClass()}
                                duration : ${groovy.time.TimeCategory.minus( new Date(), build.getTime() )}
  """
  }
}
"DONE"

• or:

  final String JOB_PATTERN = '<group>/<name>'                  // keywords
  
  jenkins.model.Jenkins.instance.getAllItems( Job.class ).findAll { Job job ->
    job.fullName.contains( JOB_PATTERN )
  }.each { Job job ->
    def build = job.getLastBuild()
    println """
                   build.getTime() : ${build.getTime()}
           build.getTimeInMillis() : ${build.getTimeInMillis()}
              build.getTimestamp() : ${build.getTimestamp()}
      build.getStartTimeInMillis() : ${build.getStartTimeInMillis()}
        build.getTimestampString() : ${build.getTimestampString()}
       build.getTimestampString2() : ${build.getTimestampString2()}
    """
  }
  

• result:

                 build.getTime() : Thu Apr 29 04:08:08 PDT 2021
         build.getTimeInMillis() : 1619694488799
            build.getTimestamp() : java.util.GregorianCalendar[time=1619694488799,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="America/Los_Angeles",offset=-28800000,dstSavings=3600000,useDaylight=true,transitions=185,lastRule=java.util.SimpleTimeZone[id=America/Los_Angeles,offset=-28800000,dstSavings=3600000,useDaylight=true,startYear=0,startMode=3,startMonth=2,startDay=8,startDayOfWeek=1,startTime=7200000,startTimeMode=0,endMode=3,endMonth=10,endDay=1,endDayOfWeek=1,endTime=7200000,endTimeMode=0]],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=3,WEEK_OF_YEAR=18,WEEK_OF_MONTH=5,DAY_OF_MONTH=29,DAY_OF_YEAR=119,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=5,AM_PM=0,HOUR=4,HOUR_OF_DAY=4,MINUTE=8,SECOND=8,MILLISECOND=799,ZONE_OFFSET=-28800000,DST_OFFSET=3600000]
    build.getStartTimeInMillis() : 1619694488807
      build.getTimestampString() : 2 min 1 sec
     build.getTimestampString2() : 2021-04-29T11:08:08Z
  

get started build time

[!NOTE|label:references:] get lastBuild start time

final String JOB_PATTERN = '<group>/<name>'                  // keywords

jenkins.model.Jenkins.instance.getAllItems( Job.class ).findAll { Job job ->
  job.fullName.contains( JOB_PATTERN )
}.each { Job job ->
  def build = job.getLastBuild()
  println groovy.time.TimeCategory.minus( new Date(), build.getTime() )
  println ( new Date(build.startTimeInMillis).format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'") )
  println build.getTime()
}

"DONE"

-- result --
14 hours, 37 minutes, 25.397 seconds
2024-02-14T04:06:30.021Z
Wed Feb 14 04:06:30 PST 2024

sort last build

[!TIP|label:references:]

• Date.format(String format))
• Convert milliseconds to yyyy-MM-dd date-time format in Groovy
• java.util.Date
• * imarslo : groovy/time
• details:

  java.util.Date                                           : job.getLastBuild()?.getTime()
  java.lang.Long                                           : job.getLastBuild()?.getTimeInMillis()
  Date.getTime()      : java.util.Date -> java.lang.Long   : job.getLastBuild()?.getTime()          -> job.getLastBuild()?.getTime().getTime()
  Date.format(String) : java.lang.Long -> java.lang.String : job.getLastBuild()?.getTimeInMillis()  -> new Date(job.getLastBuild()?.getTimeInMillis())?.format("yyyy-MM-dd'T'HH : mm : ss.SSS'Z'")
  

• example:

  println "${job.getLastBuild()?.getTime()} ~> ${job.getLastBuild()?.getTime()?.getClass()}"
  println "${new Date(job.getLastBuild()?.getTimeInMillis())?.format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")} ~> ${new Date(job.getLastBuild()?.getTimeInMillis())?.format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")?.getClass()}"
  println "${job.getLastBuild()?.getTimeInMillis()} ~> ${job.getLastBuild()?.getTimeInMillis()?.getClass()}"
  println "${job.getLastBuild()?.getTime()?.getTime()} ~> ${job.getLastBuild()?.getTime()?.getTime()?.getClass()}"
  
  -- result --
  Thu Aug 11 06:28:00 PDT 2022 ~> class java.util.Date
  2022-08-11T06:28:00.220Z ~> class java.lang.String
  1660224480220 ~> class java.lang.Long
  1660224480220 ~> class java.lang.Long
  

List<String> projects = [ 'project-1', 'project-2', 'project-n' ]

jenkins.model.Jenkins.instance
       .getAllItems( Job.class )
       .findAll { projects.any { p -> it.fullName.startsWith(p) } }
       .collectEntries {[ (it.fullName) : it.getLastBuild()?.getTime() ]}
       .sort() { a, b -> b.value?.getTime() <=> a.value?.getTime() }           // Date to timeToMillis
       .each { println "${it.key.padRight(30)} ~> ${it.value}" }

"DONE"

• result:

  marslo/dangling                ~> Fri Nov 04 02:28:14 PDT 2022
  marslo/abort                   ~> Thu Aug 11 06:28:00 PDT 2022
  marslo/dump                    ~> Thu Aug 11 01:29:39 PDT 2022
  marslo/agent                   ~> Tue Aug 09 06:19:43 PDT 2022
  marslo/docker                  ~> null
  Result: DONE
  

sort all buildable jobs

jenkins.model.Jenkins.instance
       .getAllItems( org.jenkinsci.plugins.workflow.job.WorkflowJob.class )
       .findAll { it.isBuildable() }
       .collectEntries {[ (it.fullName + ' #' + it.getLastBuild()?.id) : it.getLastBuild()?.getTime() ]}
       .sort() { a, b -> b.value?.getTime() <=> a.value?.getTime() }           // Date to timeToMillis
       .each { println "${it.key.padRight(40)} ~> ${it.value}" }

"DONE"

list builds

last N builds

list last built N jobs

Integer count = N
jenkins.model.Jenkins.instance.getAllItems( hudson.model.Job.class )
       .findAll { it.lastBuild }
       .collectEntries{[ (it.lastBuild.startTimeInMillis): it.lastBuild.absoluteUrl ]}
       .sort{ a, b -> a.key <=> b.key }
       .iterator().reverse().take(count).collect{ it.value }

// or
jenkins.model.Jenkins.instance.getAllItems( hudson.model.Job.class )
       .findAll { it.lastBuild }
       .collectEntries{[ (it.lastBuild.startTimeInMillis): it.lastBuild ]}
       .sort{ a, b -> a.key <=> b.key }
       .collect { it.value }.reverse().take(count)
       .collect { it.fullDisplayName }

list last N builds

Integer count = 5

jenkins.model.Jenkins.instance.getAllItems( hudson.model.Job.class )
       .findAll { it.lastBuild }
       .collectEntries {
          def build = it.lastBuild
          (0..<count).inject([:]) { builds, x ->
            if ( build ) {
              builds << [ (build.startTimeInMillis): build ]
              build = build?.previousBuild ?: null
            }
            builds
          }
       }.sort{ a, b -> a.key <=> b.key }
        .collect { it.value }.reverse().take(count)
        .collect { it.fullDisplayName }

// or
jenkins.model.Jenkins.instance.getAllItems( hudson.model.Job.class )
       .findAll { it.lastBuild }
       .collectEntries {
         Map builds   = [:]
         def build    = it.lastBuild
         Boolean flag = build || false
         while ( flag ) {
           builds << [ (build.startTimeInMillis): build ]
           build  = build?.previousBuild ?: null
           flag   = build && ( it.lastBuild.number - build.number < count )
         }
         builds
       }.sort{ a, b -> a.key <=> b.key }
        .collect { it.value }.reverse().take(count)
        .collect { it.fullDisplayName }

running builds

[!NOTE|label:references:]

• find-running-pipeline-jobs.groovy

jenkins.model.Jenkins.instance.computers
             .collect { it.executors }
             .flatten()
             .findAll { it.isBusy() }
             .collect { it.currentExecutable.parentExecutable }

list all running builds via pattern

import static groovy.json.JsonOutput.*

final String JOB_PATTERN                 = '<group>[/<name>]'                         // project/job keywords
Map<String, Map<String, String>> results = [:]

jenkins.model.Jenkins.instance.getAllItems(Job.class).findAll { Job job ->
  job.fullName.contains( JOB_PATTERN )
}.each { Job job ->
  results.(job.fullName) = job.builds.findAll { Run run ->
    run.isBuilding()                                                                  // or `run.result.equals(null)`
  }.collectEntries { Run run ->
    [ (run.id) : run.getAbsoluteUrl() ]
  }
}

results.findAll{ !it.value.isEmpty() }
       .each { name, builds ->
         println ">> ${name} : ${builds.size()} :" +
                 '\n\t - ' + builds.collect{ "#${it.key} : ${it.value}" }.join('\n\t - ')
       }

"DONE"

list builds running more than 24 hours via executor

final long BENCH_MARK    = 1*24*60*60*1000
final Calendar RIGHT_NOW = Calendar.getInstance()

jenkins.model.Jenkins.instance.computers
       .collect { it.executors }
       .flatten()
       .findAll { it.isBusy() }
       .collect { it.currentExecutable.parentExecutable }
       .findAll { build -> ( RIGHT_NOW.getTimeInMillis() - build.startTimeInMillis ) >= BENCH_MARK }
       .each { build ->
         println "${build.fullDisplayName} started at : ${groovy.time.TimeCategory.minus( new Date(), build.getTime() )}"
       }

• show UserIdCause.userId:

  import org.jenkinsci.plugins.workflow.job.WorkflowRun
  
  final long BENCH_MARK    = 1*24*60*60*1000
  final Calendar RIGHT_NOW = Calendar.getInstance()
  
  List<WorkflowRun> builds = jenkins.model.Jenkins.instance.computers
         .collect { it.executors }
         .flatten()
         .findAll { it.isBusy() }
         .collect { it.currentExecutable.parentExecutable }
         .findAll { ( RIGHT_NOW.getTimeInMillis() - it.startTimeInMillis ) >= BENCH_MARK }
  
  builds.each { build ->
    println ">> ${build.fullDisplayName} :" +
            "\n\t - started " + groovy.time.TimeCategory.minus( new Date(), build.getTime() ) +
            "\n\t - triggerd by " + build.getCause( Cause.UserIdCause.class ).userId
  }
  
  "DONE"
  

• list job which running for more than 24 hours

  [!TIP] only for lastBuild.

  /**
   * We had to write this script several times. Time to have it stored, it is a very simple approach but will serve as starting point for more refined approaches.
  **/
  
  jeniins.model.jenkins.model.Jenkins.instance.getAllItems( Job )
                  .findAll{ job -> job.isBuildable() }
                  .each { job ->
                    def build = job.getLastBuild()
                    def runningSince = groovy.time.TimeCategory.minus( new Date(), build.getTime() )
                    if ( runningSince.hours >= 24 ){
                      println job.name +"---- ${runningSince.hours} hours:${runningSince.minutes} minutes"
                    }
                  }
  "DONE"
  

list builds running more than 24 hours via pattern

[!NOTE|label:references:]

• scripts:
  • findRunningPipelineJobs.groovy

import hudson.model.Job
import hudson.model.Result
import hudson.model.Run
import java.util.Calendar
import jenkins.model.Jenkins

final Calendar RIGHT_NOW = Calendar.getInstance()
final long BENCH_MARK    = 1*24*60*60*1000
final String JOB_PATTERN = '<group>/<name>'

jenkins.model.Jenkins.instance.getAllItems(Job.class).findAll { Job job ->
  job.fullName.startsWith( JOB_PATTERN )
}.collect { Job job ->
  job.builds.findAll { Run run ->
    run.isBuilding() &&
    ( RIGHT_NOW.getTimeInMillis() - run.getStartTimeInMillis() ) <= BENCH_MARK
  }
}.sum()

via job pattern

import hudson.model.Job
import hudson.model.Result
import hudson.model.Run
import jenkins.model.Jenkins

final String JOB_PATTERN = '<group>/<name>'

jenkins.model.Jenkins.instance.getAllItems(Job.class).findAll { Job job ->
  job.fullName.startsWith( JOB_PATTERN )
}.collectEntries { Job job ->
  [ ( job.fullName ) : job.builds.findAll { Run run -> run.isBuilding() }.collect { Run run -> run.id } ]
}.findAll{ it.value }
 .each { println "${it.key} : ${it.value.size()} :\n\t#${it.value.join(', #')}\n" }

"DONE"

list all builds byTimestamp within 24 hours

[!TIP|label:references:]

• hudson.util.RunList
• List Jenkins job build detials for last one year along with the user who triggered the build
• public RunList<R> byTimestamp(long start, long end))

  Filter the list by timestamp. s<=e.
  Warning: this method mutates the original list and then returns it.
  

String JOB_PATTERN      = '<group>[/<name>]'                  // keywords
final long CURRENT_TIME = System.currentTimeMillis()
final int BENCH_MARK    = 1*24*60*60*1000                     // days * hours * minutes * seconds * microseconds (1000)

jenkins.model.Jenkins.instance.getAllItems(Job.class).findAll { Job job ->
  job.fullName.contains( JOB_PATTERN )
}.each { Job job ->
  def history = job.getBuilds().byTimestamp( CURRENT_TIME - BENCH_MARK, CURRENT_TIME )
  if ( history ) {
    println """
      >> ${job.fullName} : ${history.size()} :
         history         : ${history.join('\n\t\t\t    ')}
    """
  }
}

get last 24 hours failure builds

import hudson.model.Job
import hudson.model.Result
import hudson.model.Run
import java.util.Calendar
import jenkins.model.Jenkins

final Calendar RIGHT_NOW = Calendar.getInstance()
final long BENCH_MARK    = 1*24*60*60*1000
final String JOB_PATTERN = '<group>'

List<List<String, String>> results = jenkins.model
                                            .Jenkins
                                            .instance
                                            .getAllItems(Job.class)
                                            .findAll { Job job -> job.fullName.contains( JOB_PATTERN ) }
                                            .collect { Job job ->
                                                        job.builds.findAll { Run run ->
                                                          run.result == Result.FAILURE &&
                                                          ( RIGHT_NOW.getTimeInMillis() - run.getStartTimeInMillis() ) <= BENCH_MARK
                                                        }
                                                      }
                                            .sum()
                                            .collect {[ "${it.fullDisplayName}", "${it.absoluteUrl}" ]}
results.add( 0, results.transpose().collect { column -> column.collect{ it.size() }.max() } )

println results.withIndex().collect { raw, idx ->
  if ( idx ) {
    raw.withIndex().collect { x, y -> "${x.padRight(results[0][y])}" }.join(' | ')
  }
}.findAll().join('\n')

-- result --
marslo » sandbox » pipeline #3549 | https://jenkins.sample.com/job/marslo/job/sandbox/job/pipeline/3549/
marslo » whitebox » builder #191  | https://jenkins.sample.com/job/marslo/job/whitebox/job/builder/191/
marslo » sample #510              | https://jenkins.sample.com/job/marslo/job/sample/510/
marslo » sample #505              | https://jenkins.sample.com/job/marslo/job/sample/505/

• without table format

  import hudson.model.Job
  import hudson.model.Result
  import hudson.model.Run
  import java.util.Calendar
  import jenkins.model.Jenkins
  
  final Calendar RIGHT_NOW = Calendar.getInstance()
  final long BENCH_MARK    = 1*24*60*60*1000
  final String JOB_PATTERN = '<group>'
  
  jenkins.model.Jenkins.instance.getAllItems(Job.class).findAll { Job job ->
    job.fullName.contains( JOB_PATTERN )
  }.collect { Job job ->
    job.builds.findAll { Run run ->
      run.result == Result.FAILURE &&
      ( RIGHT_NOW.getTimeInMillis() - run.getStartTimeInMillis() ) <= BENCH_MARK
    }
  }.sum()
  

get last 24 hours failure builds in Map structure

import hudson.model.Job
import hudson.model.Result
import hudson.model.Run
import java.util.Calendar
import jenkins.model.Jenkins
import static groovy.json.JsonOutput.*

final Calendar RIGHT_NOW = Calendar.getInstance()
final long BENCH_MARK    = 1*24*60*60*1000
final String JOB_PATTERN = '<group>'
Map results              = [:]

jenkins.model.Jenkins.instance.getAllItems(Job.class).findAll { Job job ->
  job.fullName.contains( JOB_PATTERN )
}.each { Job job ->
  results.(job.fullName) = job.builds.findAll { Run run ->
    ! run.isBuilding() &&
    run.result == Result.FAILURE &&
    ( RIGHT_NOW.getTimeInMillis() - run.getStartTimeInMillis() ) <= BENCH_MARK
  }.collectEntries { Run run ->
    [ (run.id) : run.getAbsoluteUrl() ]
  }
}

println prettyPrint( toJson(results.findAll{ !it.value.isEmpty() }) )

• or

  import hudson.model.Job
  import hudson.model.Result
  import hudson.model.Run
  import jenkins.model.Jenkins
  import static groovy.json.JsonOutput.*
  
  final long CURRENT_TIME  = java.util.Calendar.getInstance().getTimeInMillis()
  final long BENCH_MARK    = 1*24*60*60*1000
  final String JOB_PATTERN = '<group>'
  
  Map results = [:]
  
  jenkins.model.Jenkins.instance.getAllItems(Job.class).findAll { Job job ->
    job.fullName.contains( JOB_PATTERN )
  }.each { Job job ->
    results.(job.fullName) = job.getBuilds().byTimestamp( CURRENT_TIME - BENCH_MARK, CURRENT_TIME ).findAll { Run run ->
      ! run.isBuilding() &&
      run.result == Result.FAILURE
    }.collectEntries { Run run ->
      [ run.id, run.getAbsoluteUrl() ]
    }
  }
  
  println prettyPrint( toJson(results.findAll{ !it.value.isEmpty() }) )
  

• or

  import hudson.model.Job
  import hudson.model.Result
  import hudson.model.Run
  import jenkins.model.Jenkins
  import static groovy.json.JsonOutput.*
  
  final long CURRENT_TIME  = java.util.Calendar.getInstance().getTimeInMillis()
  final long BENCH_MARK    = 1*24*60*60*1000
  final String JOB_PATTERN = '<group>'
  
  Map results = [:]
  
  jenkins.model.Jenkins.instance.getAllItems(Job.class).findAll { Job job ->
    job.fullName.contains(JOB_PATTERN)
  }.each { Job job ->
    def history = job.getBuilds().byTimestamp( CURRENT_TIME - BENCH_MARK, CURRENT_TIME )
    if( history ) {
      results.(job.fullName) = history.findAll { Run run ->
        !run.isBuilding() &&
        run.result == Result.FAILURE
      }.collectEntries { Run run ->
        [ (run.id) : run.getAbsoluteUrl() ]
      }
    }
  }
  
  println prettyPrint( toJson(results.findAll{ !it.value.isEmpty() }) )
  

via results

get all builds result percentage

final String JOB_PATTERN = '<group>/<name>'
Map<String, Map<String, String>> results = [:]
int sum = 0

jenkins.model.Jenkins.instance.getAllItems( Job.class ).findAll{ project ->
  project.fullName.contains( JOB_PATTERN )
  // or
  // project.fullName.startsWith( JOB_PATTERN )
}.each { project ->
  results."${project.fullName}" = [ SUCCESS:0, UNSTABLE:0, FAILURE:0, ABORTED:0, INPROGRESS:0, NOT_BUILT:0 ]
  def build = project.getLastBuild()
  while ( build ) {
    // if job is building, then results."${project.fullName}"."${build.result}" will be null
    if ( build.isBuilding() ) {
      results."${project.fullName}".INPROGRESS = results."${project.fullName}".INPROGRESS + 1
    } else {
      // println "$project.name;$build.id;$build.result"
      results."${project.fullName}"."${build.result}" = results."${project.fullName}"."${build.result}" + 1
    }
    build = build.getPreviousBuild()
  }
}
results.each{ name, status ->
  sum = status.values().sum()
  println "${name}: ${sum} : "
  status.each{ r, c ->
    if ( c ) println "\t${r.padRight(11)}: ${c.toString().padRight(10)}: percentage: " + (sum ? "${c * 100 / sum}%" : '0%')
  }
}
"DONE"

get builds result percentage ( within 24 hours )

final String JOB_PATTERN = '<group>'
final long CURRENT_TIME  = System.currentTimeMillis()
final int BENCH_MARK     = 1*24*60*60*1000

Map<String, Map<String, List<String>>> results = [:]
int sum = 0

jenkins.model.Jenkins.instance.getAllItems( Job.class ).findAll { project ->
  project.fullName.startsWith( JOB_PATTERN )
}.each { project ->
  if ( project.getBuilds().byTimestamp(CURRENT_TIME - BENCH_MARK, CURRENT_TIME).size() > 0 ) {
    results."${project.fullName}" = [:]
    def build = project.getLastBuild()
    while ( build && (CURRENT_TIME - build.startTimeInMillis) <= BENCH_MARK ) {
      String key = build.isBuilding() ? 'INPROGRESS' : "${build.result}"
      results."${project.fullName}"."${key}" = ( results."${project.fullName}".getOrDefault( key, [] ) << build )
      build = build.getPreviousBuild()
    }
  }
}

results.each { name, status ->
  sum = status.values().flatten().size()
  println "\n>> ${name}: ${sum} : "
  println status.collect { r, b ->
    "\t${r.padRight(10)}: ${b.size()}: ( " + ( sum ? "${b.size()*100/sum}%" : '0%' ) + ' )' +
    '\n\t  -' + b.collect {"\t${it.id} : " + new Date(it.startTimeInMillis).format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")}.join('\n\t  -')
  }.join('\n')
}

"DONE"

-- result --
>> marslo/whitebox/sample: 5 :
  SUCCESS   : 3: ( 60% )
    - 193 : 2024-02-20T01:15:48.536Z
    - 192 : 2024-02-19T22:19:12.759Z
    - 190 : 2024-02-19T20:37:42.204Z
  FAILURE   : 1: ( 20% )
    - 191 : 2024-02-19T21:53:17.644Z
  NOT_BUILT : 1: ( 20% )
    - 189 : 2024-02-19T06:01:43.875Z

>> marslo/sandbox/script: 3 :
  FAILURE   : 3: ( 100% )
    - 84 : 2024-02-20T00:38:18.385Z
    - 83 : 2024-02-19T21:01:42.314Z
    - 82 : 2024-02-19T03:00:13.123Z

>> marslo/sandbox/pipeline: 8 :
  NOT_BUILT : 5: ( 62.5% )
    - 3553 : 2024-02-20T21:51:00.713Z
    - 3552 : 2024-02-20T15:51:00.727Z
    - 3551 : 2024-02-20T09:51:00.729Z
    - 3548 : 2024-02-19T15:51:00.721Z
    - 3547 : 2024-02-19T09:51:00.726Z
  SUCCESS   : 2: ( 25% )
    - 3550 : 2024-02-20T03:51:00.713Z
    - 3546 : 2024-02-19T03:51:00.707Z
  FAILURE   : 1: ( 12.5% )
    - 3549 : 2024-02-19T21:51:00.722Z

• with percentage only

  final String JOB_PATTERN = '<group>'
  final long CURRENT_TIME  = System.currentTimeMillis()
  final int BENCH_MARK     = 1*24*60*60*1000
  
  Map<String, Map<String, String>> results = [:]
  int sum = 0
  
  jenkins.model.Jenkins.instance.getAllItems( Job.class ).findAll{ project ->
    project.fullName.startsWith( JOB_PATTERN )
    // or
    // project.fullName.contains( JOB_PATTERN )
  }.each { project ->
    if ( project.getBuilds().byTimestamp(CURRENT_TIME - BENCH_MARK, CURRENT_TIME).size() > 0 ) {
      results."${project.fullName}" = [ SUCCESS:0, UNSTABLE:0, FAILURE:0, ABORTED:0, INPROGRESS:0, NOT_BUILT:0 ]
      def build = project.getLastBuild()
  
      while ( build && (CURRENT_TIME - build.startTimeInMillis) <= BENCH_MARK ) {
        if ( build.isBuilding() ) {
          results."${project.fullName}".INPROGRESS = results."${project.fullName}".INPROGRESS + 1
        } else {
          results."${project.fullName}"."${build.result}" = results."${project.fullName}"."${build.result}" + 1
        } // if job is building, then results."${project.fullName}"."${build.result}" will be null
        build = build.getPreviousBuild()
      } // traverse in the whole traverse builds
  
    } // if there's builds within 24 hours
  }
  
  results.each{ name, status ->
    sum = status.values().sum()
    println "\n>> ${name}: ${sum} : "
    status.each{ r, c ->
      if ( c ) println "\t${r.padRight(11)}: ${c.toString().padRight(5)}: percentage: " +
                       ( sum ? "${c * 100 / sum}%" : '0%' )
    }
  }
  
  "DONE"
  

get builds result data range

[!TIP]

• find only String type parameters:

  Map params = build?.getAction( ParametersAction.class )?.parameters?.findAll{ it instanceof StringParameterValue }?.dump()
  

• scripts:
  • jobExecutedInDateRange.groovy

import java.text.SimpleDateFormat
import java.util.Date
import static groovy.json.JsonOutput.*

final String JOB_PATTERN = '<group>[/<name>]'                        // keywords
final Map<String, String> PARAM = [ 'param_name' : 'param_value' ]
Map<String, Map<String, String>> results = [:]

SimpleDateFormat simpleDateFormat = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" )
final String START_DATE = '2021-04-26 00:00:00'
final String END_DATE   = '2021-04-27 00:00:00'

long start = simpleDateFormat.parse( START_DATE ).getTime()
long end   = simpleDateFormat.parse( END_DATE ).getTime()

jenkins.model.Jenkins.instance.getAllItems( Job.class ).findAll { Job job ->
  job.fullName.contains( JOB_PATTERN )
}.each { Job job ->
  results."${job.fullName}" = [:]
  job.getBuilds().byTimestamp( start, end ).each { Run build ->
    Map params = build?.getAction( ParametersAction.class )?.parameters?.findAll{ it instanceof StringParameterValue }?.collectEntries {
                   [ it.name, it.value ]
                 }
    results."${job.fullName}"."${build.getId()}" = [
            'time' : build.getTime().toString() ,
          'params' : params?.collect { k, v -> "${k} : ${v}"},
      'paramsExist': params?.entrySet()?.containsAll( PARAM.entrySet() )
    ]
    if ( build.isBuilding() ) {
      results."${job.fullName}"."${build.getId()}" << [ 'status' : 'INPROGRESS' ]
    } else {
      results."${job.fullName}"."${build.getId()}" << [ 'status' : build.getResult().toString() ]
    }
  }

  println prettyPrint( toJson(results) )
}

int count = 0
results.get( JOB_PATTERN ).each { k, v ->
  if ( v.paramsExist ) {
    count += 1
    println """
      #${k} : ${v.status} : ${v.time}
              ${v.params}
    """
  }
}

println "total number: ${count}"
"DONE"