add support for limiting job concurrency based on one or more build parameters

README

@@ -1,3 +1,16 @@
 Work in progress on a plugin to dynamically allocate labels in order
 to allow for throttling the number of concurrent builds of a project
 allowed to run on a given node at one time.
+
+Contributing
+------------
+
+### Run / Debug cycle:
+
+Execute `mvn hpi:run`. This will compile the plugin and launch a Jenkins instance on http://localhost:8080
+
+### Create Package (.hpi):
+
+Execute `mvn hpi:hpi`. This will create `throttle-concurrent.hpi` in the `target/` directory
+
+For other mvn targets, see: https://jenkins-ci.org/maven-hpi-plugin/

pom.xml

@@ -26,13 +26,13 @@ THE SOFTWARE.
   <parent>
     <groupId>org.jenkins-ci.plugins</groupId>
     <artifactId>plugin</artifactId>
-    <version>1.399</version>
+    <version>1.518</version>
   </parent>
 
   <artifactId>throttle-concurrents</artifactId>
   <packaging>hpi</packaging>
   <name>Jenkins Throttle Concurrent Builds Plug-in</name>
-  <version>1.7.3-SNAPSHOT</version>
+  <version>1.7.5-SNAPSHOT</version>
   <url>http://wiki.jenkins-ci.org/display/JENKINS/Throttle+Concurrent+Builds+Plugin</url>
   <description>Plugin to throttle the number of concurrent builds of a single job per node.</description>
 

src/main/java/hudson/plugins/throttleconcurrents/ThrottleJobProperty.java

@@ -34,6 +34,8 @@ public class ThrottleJobProperty extends JobProperty<AbstractProject<?,?>> {
     private List<String> categories;
     private boolean throttleEnabled;
     private String throttleOption;
+    private boolean limitOneJobWithMatchingParams;
+    private String limitOneJobByParams;
 
     /**
      * Store a config version so we're able to migrate config on various
@@ -46,12 +48,16 @@ public ThrottleJobProperty(Integer maxConcurrentPerNode,
                                Integer maxConcurrentTotal,
                                List<String> categories,
                                boolean throttleEnabled,
-                               String throttleOption) {
+                               String throttleOption,
+                               boolean limitOneJobWithMatchingParams,
+                               String limitOneJobByParams) {
         this.maxConcurrentPerNode = maxConcurrentPerNode == null ? 0 : maxConcurrentPerNode;
         this.maxConcurrentTotal = maxConcurrentTotal == null ? 0 : maxConcurrentTotal;
         this.categories = categories;
         this.throttleEnabled = throttleEnabled;
         this.throttleOption = throttleOption;
+        this.limitOneJobWithMatchingParams = limitOneJobWithMatchingParams;
+        this.limitOneJobByParams = limitOneJobByParams;
     }
 
 
@@ -80,6 +86,7 @@ public Object readResolve() {
                 maxConcurrentTotal = 0;
             }
         }
+
         configVersion = 1L;
 
         return this;
@@ -89,6 +96,14 @@ public boolean getThrottleEnabled() {
         return throttleEnabled;
     }
 
+    public boolean getlimitOneJobWithMatchingParams() {
+        return limitOneJobWithMatchingParams;
+    }
+
+    public String getLimitOneJobByParams() {
+        return limitOneJobByParams;
+    }
+
     public String getThrottleOption() {
         return throttleOption;
     }

src/main/java/hudson/plugins/throttleconcurrents/ThrottleQueueTaskDispatcher.java

@@ -5,15 +5,20 @@
 import hudson.matrix.MatrixProject;
 import hudson.model.AbstractBuild;
 import hudson.model.AbstractProject;
+import hudson.model.ParameterValue;
 import hudson.model.Computer;
 import hudson.model.Executor;
 import hudson.model.Hudson;
 import hudson.model.Node;
 import hudson.model.Queue;
 import hudson.model.Queue.Task;
+import hudson.model.queue.WorkUnit;
 import hudson.model.queue.CauseOfBlockage;
 import hudson.model.queue.QueueTaskDispatcher;
+import hudson.model.Action;
+import hudson.model.ParametersAction;
 
+import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -35,7 +40,6 @@ public CauseOfBlockage canTake(Node node, Task task) {
         if (tjp!=null && tjp.getThrottleEnabled()) {
             CauseOfBlockage cause = canRun(task, tjp);
             if (cause != null) return cause;
-
             if (tjp.getThrottleOption().equals("project")) {
                 if (tjp.getMaxConcurrentPerNode().intValue() > 0) {
                     int maxConcurrentPerNode = tjp.getMaxConcurrentPerNode().intValue();
@@ -90,6 +94,10 @@ else if (tjp.getThrottleOption().equals("category")) {
     public CauseOfBlockage canRun(Queue.Item item) {
         ThrottleJobProperty tjp = getThrottleJobProperty(item.task);
         if (tjp!=null && tjp.getThrottleEnabled()) {
+            if (tjp.getlimitOneJobWithMatchingParams() && isAnotherBuildWithSameParametersRunningOnAnyNode(item)) {
+                LOGGER.info("A build with matching parameters is already running.");
+                return CauseOfBlockage.fromMessage(Messages._ThrottleQueueTaskDispatcher_OnlyOneWithMatchingParameters());
+            }
             return canRun(item.task, tjp);
         }
         return null;
@@ -151,6 +159,88 @@ else if (tjp.getThrottleOption().equals("category")) {
     }
 
 
+    private boolean isAnotherBuildWithSameParametersRunningOnAnyNode(Queue.Item item) {
+        if (isAnotherBuildWithSameParametersRunningOnNode(Hudson.getInstance(), item)) {
+            return true;
+        }
+
+        for (Node node : Hudson.getInstance().getNodes()) {
+            if (isAnotherBuildWithSameParametersRunningOnNode(node, item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isAnotherBuildWithSameParametersRunningOnNode(Node node, Queue.Item item) {
+        ThrottleJobProperty tjp = getThrottleJobProperty(item.task);
+        Computer computer = node.toComputer();
+        List<String> paramsToCompare = new ArrayList<String>();
+        List<ParameterValue> itemParams = getParametersFromQueueItem(item);
+
+        if (tjp.getLimitOneJobByParams().length() > 0) {
+            paramsToCompare = Arrays.asList(tjp.getLimitOneJobByParams().split(","));
+            itemParams = doFilterParams(paramsToCompare, itemParams);
+        }
+
+        if (computer != null) {
+            for (Executor exec : computer.getExecutors()) {
+                if (exec.getCurrentExecutable() != null && exec.getCurrentExecutable().getParent().getOwnerTask().getName() == item.task.getName()) {
+                    List<ParameterValue> executingUnitParams = getParametersFromWorkUnit(exec.getCurrentWorkUnit());
+                    executingUnitParams = doFilterParams(paramsToCompare, executingUnitParams);
+
+                    if (executingUnitParams.containsAll(itemParams)) {
+                        LOGGER.info("build (" + exec.getCurrentWorkUnit() + ") with identical parameters (" +
+                                    executingUnitParams + ") is already running.");
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    // takes a String array containing a list of params, a List of ParameterValue objects
+    // and returns a new List<ParameterValue> with only the desired params in the list.
+    private List<ParameterValue> doFilterParams(List<String> params, List<ParameterValue> OriginalParams) {
+        if (params.isEmpty()) {
+            return OriginalParams;
+        }
+
+        List<ParameterValue> newParams = new ArrayList<ParameterValue>();
+
+        for (ParameterValue p : OriginalParams) {
+            if (params.contains(p.getName())) {
+                newParams.add(p);
+            }
+        }
+        return newParams;
+    }
+
+    public List<ParameterValue> getParametersFromWorkUnit(WorkUnit unit) {
+        List<ParameterValue> paramsList = new ArrayList<ParameterValue>();
+
+        List<Action> actions = unit.context.actions;
+        for (Action action : actions) {
+            if (action instanceof ParametersAction) {
+                ParametersAction params = (ParametersAction) action;
+                paramsList = params.getParameters();
+            }
+        }
+        return paramsList;
+    }
+
+    public List<ParameterValue> getParametersFromQueueItem(Queue.Item item) {
+        List<ParameterValue> paramsList = new ArrayList<ParameterValue>();
+
+        ParametersAction params = item.getAction(ParametersAction.class);
+        if (params != null) {
+            paramsList = params.getParameters();
+        }
+        return paramsList;
+    }
+
+
     private ThrottleJobProperty getThrottleJobProperty(Task task) {
         if (task instanceof AbstractProject) {
             AbstractProject<?,?> p = (AbstractProject<?,?>) task;
@@ -224,4 +314,4 @@ private List<AbstractProject<?,?>> getCategoryProjects(String category) {
 
     private static final Logger LOGGER = Logger.getLogger(ThrottleQueueTaskDispatcher.class.getName());
 
-}
+}

src/main/resources/hudson/plugins/throttleconcurrents/Messages.properties

@@ -1,3 +1,4 @@
 ThrottleQueueTaskDispatcher.MaxCapacityOnNode=Already running {0} builds on node
 ThrottleQueueTaskDispatcher.MaxCapacityTotal=Already running {0} builds across all nodes
-ThrottleQueueTaskDispatcher.BuildPending=A build is pending launch
+ThrottleQueueTaskDispatcher.BuildPending=A build is pending launch
+ThrottleQueueTaskDispatcher.OnlyOneWithMatchingParameters=A build with matching parameters is already running

src/main/resources/hudson/plugins/throttleconcurrents/ThrottleJobProperty/config.jelly

@@ -20,6 +20,18 @@
              field="maxConcurrentPerNode">
       <f:textbox />
     </f:entry>
+
+    <f:optionalBlock name="limitOneJobWithMatchingParams"
+                     title="${%Prevent multiple jobs with identical parameters from running concurrently}"
+                     inline="true"
+                     checked="${instance.limitOneJobWithMatchingParams}">
+      <f:entry title="${%List of parameters to check (comma-separated)}"
+               field="limitOneJobByParams"
+               help="${descriptor.getHelpFile('limitOneJobWithMatchingParams')}">
+        <f:textbox />
+      </f:entry>
+    </f:optionalBlock>
+
     <j:if test="${!empty(descriptor.categories)}">
       <f:entry title="${%Multi-Project Throttle Category}">
         <j:forEach var="cat" items="${descriptor.categories}">

src/main/resources/hudson/plugins/throttleconcurrents/ThrottleJobProperty/help-limitOneJobWithMatchingParams.html

@@ -0,0 +1,6 @@
+<div>
+  <p>If this box is checked, only one instance of the job with matching parameters will be allowed to run at a given time.
+  Other instances of this job with different parameters will be allowed to run concurrently.</p>
+  <p>Optionally, provide a comma-separated list of parameters to use when comparing jobs. If blank, all parameters
+    must match for a job to be limited to one running instance.</p>
+</div>