JENKINS-24207: Add new selector for Perforce/P4 that allows to update JIRA issues based on jobs

pom.xml

@@ -295,6 +295,18 @@
 	  <version>1.12</version>
 	  <optional>true</optional>
 	</dependency>
+    <dependency>
+        <groupId>org.jvnet.hudson.plugins</groupId>
+        <artifactId>perforce</artifactId>
+        <version>1.3.9</version>
+        <optional>true</optional>
+    </dependency>
+    <dependency>
+        <groupId>org.jenkins-ci.plugins</groupId>
+        <artifactId>p4</artifactId>
+        <version>1.3.8</version>
+        <optional>true</optional>
+    </dependency>
 
     <!-- test dependencies -->
     <dependency>

src/main/java/hudson/plugins/jira/selector/DefaultIssueSelector.java

@@ -1,7 +1,9 @@
 package hudson.plugins.jira.selector;
 
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -27,64 +29,46 @@
 import hudson.scm.ChangeLogSet;
 import hudson.scm.ChangeLogSet.Entry;
 
-public final class DefaultIssueSelector extends AbstractIssueSelector {
+public class DefaultIssueSelector extends AbstractIssueSelector {
 
     private static final Logger LOGGER = Logger.getLogger(DefaultIssueSelector.class.getName());
 
     @DataBoundConstructor
     public DefaultIssueSelector() {
     }
 
+    /**
+     * See {@link #addIssuesRecursive(Run, JiraSite, TaskListener, Set)}
+     */
     @Override
     public Set<String> findIssueIds(@Nonnull final Run<?, ?> run, @Nonnull final JiraSite site,
             @Nonnull final TaskListener listener) {
-        return findIssueIdsRecursive(run, site.getIssuePattern(), listener);
+        HashSet<String> issuesIds = new HashSet<String>();
+        addIssuesRecursive(run, site, listener, issuesIds);
+        return issuesIds;
     }
 
     @Extension
     public static final class DescriptorImpl extends Descriptor<AbstractIssueSelector> {
 
         @Override
         public String getDisplayName() {
-            return Messages.DefaultUpdaterIssueSelector_DisplayName();
+            return Messages.DefaultIssueSelector_DisplayName();
         }
     }
 
+    protected Logger getLogger() {
+        return LOGGER;
+    }
+
     /**
      * Finds the strings that match JIRA issue ID patterns. This method returns
      * all likely candidates and doesn't check if such ID actually exists or
      * not. We don't want to use {@link JiraSite#existsIssue(String)} here so
      * that new projects in JIRA can be detected.
+     * 
      */
-    private static Set<String> findIssueIdsRecursive(Run<?, ?> build, Pattern pattern, TaskListener listener) {
-        Set<String> ids = new HashSet<String>();
-
-        // first, issues that were carried forward.
-        Run<?, ?> prev = build.getPreviousBuild();
-        if (prev != null) {
-            JiraCarryOverAction a = prev.getAction(JiraCarryOverAction.class);
-            if (a != null) {
-                ids.addAll(a.getIDs());
-            }
-        }
-
-        // then issues in this build
-        findIssues(build, ids, pattern, listener);
-
-        // check for issues fixed in dependencies
-        for (DependencyChange depc : RunScmChangeExtractor.getDependencyChanges(build.getPreviousBuild()).values()) {
-            for (AbstractBuild<?, ?> b : depc.getBuilds()) {
-                findIssues(b, ids, pattern, listener);
-            }
-        }
-        return ids;
-    }
-
-    /**
-     * @param pattern pattern to use to match issue ids
-     *            
-     */
-    protected static void findIssues(Run<?, ?> build, Set<String> ids, Pattern pattern, TaskListener listener) {
+    protected static void findIssues(Run<?, ?> build, Set<String> issueIds, Pattern pattern, TaskListener listener) {
         for (ChangeLogSet<? extends Entry> set : RunScmChangeExtractor.getChanges(build)) {
             for (Entry change : set) {
                 LOGGER.fine("Looking for JIRA ID in " + change.getMsg());
@@ -93,23 +77,102 @@ protected static void findIssues(Run<?, ?> build, Set<String> ids, Pattern patte
                 while (m.find()) {
                     if (m.groupCount() >= 1) {
                         String content = StringUtils.upperCase(m.group(1));
-                        ids.add(content);
+                        issueIds.add(content);
                     } else {
                         listener.getLogger()
                                 .println("Warning: The JIRA pattern " + pattern + " doesn't define a capturing group!");
                     }
                 }
             }
         }
+    }
 
+    /**
+     * Calls {@link #findIssues(Run, Set, Pattern, TaskListener)} with
+     * {@link JiraSite#getIssuePattern()} as pattern
+     */
+    protected void addIssuesFromChangeLog(Run<?, ?> build, JiraSite site, TaskListener listener, Set<String> issueIds) {
+        Pattern pattern = site.getIssuePattern();
+        findIssues(build, issueIds, pattern, listener);
+    }
+
+    /**
+     * Adds issues to issueIds. Adds issues carried over from previous build,
+     * issues from current build and from dependent builds
+     * {@link #addIssuesCarriedOverFromPreviousBuild(Run, JiraSite, TaskListener, Set)}
+     * {@link #addIssuesFromCurrentBuild(Run, JiraSite, TaskListener, Set)}
+     * {@link #addIssuesFromDependentBuilds(Run, JiraSite, TaskListener, Set)}
+     */
+    protected void addIssuesRecursive(Run<?, ?> build, JiraSite site, TaskListener listener, Set<String> issuesIds) {
+        addIssuesCarriedOverFromPreviousBuild(build, site, listener, issuesIds);
+        addIssuesFromCurrentBuild(build, site, listener, issuesIds);
+        addIssuesFromDependentBuilds(build, site, listener, issuesIds);
+    }
+
+    /**
+     * Adds issues to issueIds from the current build. Issues from parameters
+     * are added as well as issues matching pattern
+     * {@link #addIssuesFromChangeLog(Run, Pattern, TaskListener, Set)}
+     * {@link #addIssuesFromParameters(Run, JiraSite, TaskListener, Set)}
+     */
+    protected void addIssuesFromCurrentBuild(Run<?, ?> build, JiraSite site, TaskListener listener,
+            Set<String> issueIds) {
+        addIssuesFromChangeLog(build, site, listener, issueIds);
+        addIssuesFromParameters(build, site, listener, issueIds);
+    }
+
+    /**
+     * Adds issues to issueIds by examining dependency changes from last build.
+     * For each dependency change
+     * {@link #addIssuesRecursive(Run, JiraSite, TaskListener, Set) is called.
+     */
+    protected void addIssuesFromDependentBuilds(Run<?, ?> build, JiraSite site, TaskListener listener,
+            Set<String> issueIds) {
+        for (DependencyChange depc : RunScmChangeExtractor.getDependencyChanges(build.getPreviousBuild()).values()) {
+            for (AbstractBuild<?, ?> b : depc.getBuilds()) {
+                getLogger().finer("Searching for JIRA issues in dependency " + b + " of " + build);
+                addIssuesRecursive(b, site, listener, issueIds);
+            }
+        }
+    }
+
+    /**
+     * Adds issues to issueIds from parameters
+     */
+    protected void addIssuesFromParameters(Run<?, ?> build, JiraSite site, TaskListener listener,
+            Set<String> issueIds) {
         // Now look for any JiraIssueParameterValue's set in the build
         // Implements JENKINS-12312
         ParametersAction parameters = build.getAction(ParametersAction.class);
 
         if (parameters != null) {
             for (ParameterValue val : parameters.getParameters()) {
                 if (val instanceof JiraIssueParameterValue) {
-                    ids.add(((JiraIssueParameterValue) val).getValue().toString());
+                    String issueId = ((JiraIssueParameterValue) val).getValue().toString();
+                    if (issueIds.add(issueId)) {
+                        getLogger().finer("Added perforce issue " + issueId + " from build " + build);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Adds issues that were carried over from previous build to issueIds
+     */
+    protected void addIssuesCarriedOverFromPreviousBuild(Run<?, ?> build, JiraSite site, TaskListener listener,
+            Set<String> ids) {
+        Run<?, ?> prev = build.getPreviousBuild();
+        if (prev != null) {
+            JiraCarryOverAction a = prev.getAction(JiraCarryOverAction.class);
+            if (a != null) {
+                getLogger().finer("Searching for JIRA issues in previously failed build " + prev.number);
+                Collection<String> jobIDs = a.getIDs();
+                ids.addAll(jobIDs);
+                if (getLogger().isLoggable(Level.FINER)) {
+                    for (String jobId : a.getIDs()) {
+                        getLogger().finer("Adding job " + jobId);
+                    }
                 }
             }
         }

src/main/java/hudson/plugins/jira/selector/perforce/JobIssueSelector.java

@@ -0,0 +1,34 @@
+package hudson.plugins.jira.selector.perforce;
+
+import java.util.Set;
+
+import hudson.model.Run;
+import hudson.model.TaskListener;
+import hudson.plugins.jira.JiraSite;
+import hudson.plugins.jira.selector.DefaultIssueSelector;
+
+/**
+ * Base class for job selectors. Perforce offers mechanism to associate JIRA
+ * issues with change lists called jobs. The classes inheriting from this class
+ * find issues by examining jobs associated with changes
+ * 
+ * @author Jacek Tomaka
+ * @since 2.3
+ */
+public abstract class JobIssueSelector extends DefaultIssueSelector {
+
+    @Override
+    /**
+     * See {@link #addJobIdsFromChangeLog(Run, JiraSite, TaskListener, Set)}
+     */
+    protected void addIssuesFromChangeLog(Run<?, ?> build, JiraSite site, TaskListener listener, Set<String> issueIds) {
+        addJobIdsFromChangeLog(build, site, listener, issueIds);
+    }
+
+    /**
+     * Adds job ids from change log to issueIds.
+     */
+    protected abstract void addJobIdsFromChangeLog(Run<?, ?> build, JiraSite site, TaskListener listener,
+            Set<String> issueIds);
+
+}

src/main/java/hudson/plugins/jira/selector/perforce/P4JobIssueSelector.java

@@ -0,0 +1,74 @@
+package hudson.plugins.jira.selector.perforce;
+
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import org.jenkinsci.plugins.p4.changes.P4ChangeEntry;
+import org.kohsuke.stapler.DataBoundConstructor;
+
+import com.perforce.p4java.core.IFix;
+
+import hudson.Extension;
+import hudson.model.Descriptor;
+import hudson.model.Run;
+import hudson.model.TaskListener;
+import hudson.plugins.jira.JiraSite;
+import hudson.plugins.jira.Messages;
+import hudson.plugins.jira.RunScmChangeExtractor;
+import hudson.plugins.jira.selector.AbstractIssueSelector;
+import hudson.scm.ChangeLogSet;
+import hudson.scm.ChangeLogSet.Entry;
+
+@Extension(optional = true)
+/**
+ * Job selector for Perforce Software SCM plugin (P4)
+ * 
+ * @author Jacek Tomaka
+ * @since 2.3
+ */
+public class P4JobIssueSelector extends JobIssueSelector {
+    private static final Logger LOGGER = Logger.getLogger(P4JobIssueSelector.class.getName());
+
+    @Extension(optional = true)
+    public static final class DescriptorImpl extends Descriptor<AbstractIssueSelector> {
+
+        @Override
+        public String getDisplayName() {
+            return Messages.P4JobIssueSelector_DisplayName();
+        }
+    }
+
+    @DataBoundConstructor
+    public P4JobIssueSelector() {
+    }
+
+    @Override
+    protected void addJobIdsFromChangeLog(Run<?, ?> build, JiraSite site, TaskListener listener, Set<String> issueIds) {
+        getLogger().finer("Searching for JIRA issues in perforce jobs in " + build);
+        for (ChangeLogSet<? extends Entry> set : RunScmChangeExtractor.getChanges(build)) {
+            for (Entry change : set) {
+                getLogger().fine("Looking for JIRA IDs as Perforce Jobs in " + change.getMsg());
+                if (P4ChangeEntry.class.isAssignableFrom(change.getClass())) {
+                    P4ChangeEntry p4ChangeEntry = (P4ChangeEntry) change;
+
+                    List<IFix> jobs = p4ChangeEntry.getJobs();
+                    if (jobs != null) {
+                        for (IFix job : jobs) {
+                            String jobId = job.getJobId();
+                            if (issueIds.add(jobId)) {
+                                getLogger().finer("Added perforce job id " + jobId + " from build " + build);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    protected Logger getLogger() {
+        return LOGGER;
+    }
+
+}