The proposed ordinalGroup feature would be a workaround for a good practice: one branch, one job. Having 2 projects/branches been built by the same job is not desirable. Avoiding this is the whole point of multibranch projects. Each project should have its own multibranch job. If projects live in branches of the same repository, then use specific {{Jenkinsfile}}s in branches.

I do not see a clear use case for this. The example given in the issue description is artificial so that does not help give context.

amuniz: I would like to understand why it is not desirable to have 2 projects built by the same job? In my opinion it is a limitation as

• additional maintenance needed (DRY principle is not fulfilled)
• higher dependency to Jenkins / more Jenkins centric view
• e.g. multi branch has limitations (e.g. try to handle Subversion and GIT in one job)

For me, Jenkins is a infrastructure tool. I use it to define where data shall be processed but not how. Representation of the result is not done with Jenkins (could this be the main reason to have one job per project?)

E.g. my generalized workflow

• build is triggered by external tool
• build pulls data depending on provided parameters
• build processes data
• build pushes result to other tools (e.g. dashboard, artifactory ...)

So in case of double builds / same data shall be processed twice I would like to abort one build. Unfortunately, it is not possible with the current implementation of the milestone.

additional maintenance needed (DRY principle is not fulfilled)

Not necessarily. Use a shared library loaded from a separated SCM, then create a really simple Jenkinsfile on each project (this is the approach of the Jenkins Plugins project, this is the Jenkinsfile for the milestone plugin for example).

Maintenance would be mostly centralized in the shared library.

higher dependency to Jenkins / more Jenkins centric view

Can you elaborate? I see the same grade of dependency in both approaches.

multi branch has limitations (e.g. try to handle Subversion and GIT in one job)

You can use more than one call to `checkout` step to get Git and Subversion workspaces in the same pipeline. What's the limitation?

I use it to define where data shall be processed but not how

Pipelines are designed to define "how" the project is built (among other things), not sure what other use you could do of it.

So in case of double builds

Why would you have double builds? A commit in a specific repository should trigger a single build in the corresponding job.

I've also been looking for something similar. Our use case is that we have a shared job for deployment, we have multiple multibranch jobs which all trigger a parameterised pipeline job. In this pipeline job I'd like to combine milestones & locks to prevent running simultaneous deployments for the same app to the same environment. I can use locks to only deploy one of each app at a time (different apps can deploy in parallel). But it would be nice to use the milestone with the suggested ordinalGroup in combination with locks using inversePrecedence: true. Do you have an alternative solution to this amuniz? I see no need to have to create new jobs for each possible application & environment combination.

Did you find any solution tpeitzsch?

prevent running simultaneous deployments for the same app to the same environment

This sort of logic should probably be moved out of Jenkins itself into a deployment tool.

To be more concrete, the best practice "one branch, one job" will not work in large companies with separated teams for SW development and infrastructure development due to job maintenance (E.g. are the latest released script versions used by the SW development teams). Here the build script version must be specified centrally. Please think about more than 1000 different SW development projects / repositories with at least 10 branches (note: multibranch is not possible, legacy SCM) but only 4 different workflows.

It is a hard job to change some global configurations for more 10000 jobs  (even with Jobs DSL).

To reduce the amount of jobs I want to use one job per released pipeline script version for all related projects / repositories (or 10000 jobs running in one Job). Unfortunately the milestone step cannot be used.

flydiverny: Unfortunately not. I haven't found a real solution for this issue :/. E.g. the Job creation via Jobs DSL introduce additional infrastructure to handle the build parameters (some of them can be changed by the users and would be overwritten by the Jobs DSL)

the latest released script versions [are] used by the SW development teams [so] the build script version must be specified centrally

By the way this is easily supported in multibranch projects by moving the logic of the build into a library and then having a Jenkinsfile merely say something like

library('standard-corporate-build@master').run()

(The version identifier may be omitted if a default is specified in the library registration, and the administrator can control whether or not this version may be overridden, say to a tag or commit hash.)

Use case:
We have a single job which does PR deployments. It is triggered by each PR's own build job, but with different params, like which branch to deploy etc.

We would like to ensure that only the latest build gets deployed as it would be unnecessary to deploy older builds. Milestones and inverse locks seemed to offer a great solution to this, but milestones don't take parameters into account at all and thus it cancels jobs which have different parameters.

I think this is an essential feature that needs to be implemented in milestone.

Our pipeline is triggered by GitLab's Merge Request events. Whenever there are code updated or special comments, the job will be triggered. It is very common to have multiple builds that triggered by the same Merge Request in our pipeline.

In this case, we would hope that old builds should be aborted if there are a new build of same Merge Request. If milestone can support classification, then we can simply write 

milestone(groupLable: env.gitlab_merge_request_id)

Our pipeline is triggered by GitLab's Merge Request events.

Note that an alternate solution in this case is to use the GitLab branch source plugin, so that each MR corresponds to a distinct job. Obviously that is a big change with other impacts.

jglick

Actually I don't think the idea of one job per branch and the multi-branch pipeline is feasible for a large project. I think Jenkins 2.0 pipeline already grants us the ability to handle the multi-branch scenario and merge requests in a single pipeline script. Multi-branch pipeline may looks good if everything works ideally. But in the real world, we have already had to apply some global change to work around unexpected problems several times. And by using the one job per branch strategy, we still have to distinguish push events and merge events to do different things. Then why not just handle all of those conditions in a single pipeline script. It's hard for me to switch to multi-branch pipeline without any strong reason. 

On the other hand, by providing a namespace mechanism for milestone, just as what we already had in `lock`, can be very useful and flexible in many cases.

Created PR https://github.com/jenkinsci/pipeline-milestone-step-plugin/pull/17

We're also currently running into a situation where we require some functionality similar the groups suggested here.

We have a single job, triggered by various branches of a multibranch pipeline that fetches upstream artifacts, builds docker images from them and pushes them to an internal registry.

To ensure that no outdated images are published on the registry we use a combination of the milestone and lock steps. The problem we're now facing is that (contrary to the lock step) the milestone step does not allow to identify milestones by means of a string label instead of an ordinal. If using a string label was possible we could dynamically create a label to disambiguate upstream branches. Using group labels - as suggested by this report - would also provide us with the means to solve the problem, but my personal opinion is that simply allowing for a textual milestone identifier would be a simpler, but equally as powerful solution.