getRequiredMonitorService

Declares the scope of the synchronization monitor this BuildStep expects from outside.

This method is introduced for preserving compatibility with plugins written for earlier versions of Hudson,
which never run multiple builds of the same job in parallel. Such plugins often assume that the outcome
of the previous build is completely available, which is no longer true when we do concurrent builds.

To minimize the necessary code change for such plugins, BuildStep implementations can request
Hudson to externally perform synchronization before executing them. This behavior is as follows:

This BuildStep is only executed after the same step in the previous build is completed.
For build steps that use a weaker assumption and only rely on the output from the same build step of
the early builds, this improves the concurrency.

No external synchronization is performed on this build step. This is the most efficient, and thus
the recommended value for newer plugins. Wherever necessary, you can directly use CheckPoints
to perform necessary synchronizations.

Migrating Older Implementation

If you are migrating BuildStep implementations written for earlier versions of Hudson,
here's what you can do:

To demand the backward compatible behavior from Jenkins, leave this method unoverridden,
and make no other changes to the code. This will prevent users from reaping the benefits of concurrent
builds, but at least your plugin will work correctly, and therefore this is a good easy first step.

If your build step doesn't use anything from a previous build (for example, if you don't even call
Run.getPreviousBuild()), then you can return BuildStepMonitor.NONE without making further
code changes and you are done with migration.

If your build step only depends on Actions that you added in the previous build by yourself,
then you only need BuildStepMonitor.STEP scope synchronization. Return it from this method
,and you are done with migration without any further code changes.

owner - The project that owns the publishers, builders, etc.
This information is conceptually redundant, as those objects are
only configured against the single owner, but this information is
nevertheless passed in since often owner information is not recorded.
Never null.