feat: add caching feature to jobfinder (refs #272)

README.md

@@ -65,14 +65,24 @@ The token can be supplied as a:
 
 - Request parameter:
 
-  `curl -vs http://localhost:8080/jenkins/generic-webhook-trigger/invoke?token=abc123 2>&1`
+  `curl -vs "http://localhost:8080/jenkins/generic-webhook-trigger/invoke?token=abc123" 2>&1`
 - Token header:
 
-  `curl -vs -H "token: abc123" http://localhost:8080/jenkins/generic-webhook-trigger/invoke 2>&1`
+  `curl -vs -H "token: abc123" "http://localhost:8080/jenkins/generic-webhook-trigger/invoke" 2>&1`
   - It will also detect `X-Gitlab-Token`.
 - _Authorization_ header of type _Bearer_ :
 
-  `curl -vs -H "Authorization: Bearer abc123" http://localhost:8080/jenkins/generic-webhook-trigger/invoke 2>&1`
+  `curl -vs -H "Authorization: Bearer abc123" "http://localhost:8080/jenkins/generic-webhook-trigger/invoke" 2>&1`
+
+### Cache parameter
+
+There is a special `usecache` parameter. When supplied, the plugin will cache configured jobs for `15` minutes. After the first invocation, useing this parameter, the plugin will automatically refresh the cache so that any future calls will use the cached value. This means the effect of any changes to any configured job will be delayed.
+
+The cache will only be used if a `token` is also supplied.
+
+The cache will be used when `usecache=true` parameter is passed like this:
+
+  `curl -vs "http://localhost:8080/jenkins/generic-webhook-trigger/invoke?token=abc123&usecache=true" 2>&1`
 
 ## Trigger exactly one build
 
@@ -106,26 +116,26 @@ If you are fiddling with expressions, you may want to checkout:
 It's probably easiest to do with `curl`. Given that you have configured a Jenkins job to trigger on Generic Webhook, here are some examples of how to start the jobs.
 
 ```bash
-curl -vs http://localhost:8080/jenkins/generic-webhook-trigger/invoke 2>&1
+curl -vs "http://localhost:8080/jenkins/generic-webhook-trigger/invoke" 2>&1
 ```
 
 This should start your job, if the job has no `token` configured and no security enabled. If you have security enabled you may need to authenticate:
 
 ```bash
-curl -vs http://theusername:thepasssword@localhost:8080/jenkins/generic-webhook-trigger/invoke 2>&1
+curl -vs "http://theusername:thepasssword@localhost:8080/jenkins/generic-webhook-trigger/invoke" 2>&1
 ```
 
 If your job has a `token` you don't need to supply other credentials. You can specify the `token` like this:
 
 ```bash
-curl -vs http://localhost:8080/jenkins/generic-webhook-trigger/invoke?token=TOKEN_HERE 2>&1
+curl -vs "http://localhost:8080/jenkins/generic-webhook-trigger/invoke?token=TOKEN_HERE" 2>&1
 ```
 Please keep in mind, using a token always runs the triggered jobs with SYSTEM privileges.
 
 If you want to trigger with `token` and some post content, `curl` can dot that like this.
 
 ```bash
-curl -v -H "Content-Type: application/json" -X POST -d '{ "app":{ "name":"some value" }}' http://localhost:8080/jenkins/generic-webhook-trigger/invoke?token=TOKEN_HERE
+curl -v -H "Content-Type: application/json" -X POST -d '{ "app":{ "name":"some value" }}' "http://localhost:8080/jenkins/generic-webhook-trigger/invoke?token=TOKEN_HERE"
 ```
 
 ## Screenshots
@@ -372,7 +382,7 @@ pipeline {
 It can be triggered with something like:
 
 ```bash
-curl -X POST -H "Content-Type: application/json" -H "headerWithNumber: nbr123" -H "headerWithString: a b c" -d '{ "before": "1848f12", "after": "5cab1", "ref": "refs/heads/develop" }' -vs http://admin:admin@localhost:8080/jenkins/generic-webhook-trigger/invoke?requestWithNumber=nbr%20123\&requestWithString=a%20string
+curl -X POST -H "Content-Type: application/json" -H "headerWithNumber: nbr123" -H "headerWithString: a b c" -d '{ "before": "1848f12", "after": "5cab1", "ref": "refs/heads/develop" }' -vs "http://admin:admin@localhost:8080/jenkins/generic-webhook-trigger/invoke?requestWithNumber=nbr%20123&requestWithString=a%20string"
 ```
 
 And the job will have this in the log:

debug.sh

@@ -1,4 +1,8 @@
 #!/bin/sh
-mvn versions:update-properties
-mvnDebug -q hpi:run -Djava.util.logging.config.file=logging.properties -Djenkins.version=2.204.1 -Denforcer.skip=true
-
+./mvnw versions:update-properties
+MAVEN_OPTS="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,address=8000,suspend=n" \
+ ./mvnw hpi:run \
+ -Djava.util.logging.config.file=logging.properties \
+ -Djenkins.version=2.361.4 \
+ -Denforcer.skip=true \
+ -Dhudson.model.ParametersAction.keepUndefinedParameters=true

run.sh

@@ -1,3 +1,7 @@
 #!/bin/sh
-mvn versions:update-properties
-mvn hpi:run -Djava.util.logging.config.file=logging.properties -Djenkins.version=2.346.3 -Denforcer.skip=true
+./mvnw versions:update-properties
+./mvnw hpi:run \
+ -Djava.util.logging.config.file=logging.properties \
+ -Djenkins.version=2.361.4 \
+ -Denforcer.skip=true \
+ -Dhudson.model.ParametersAction.keepUndefinedParameters=true

src/main/java/org/jenkinsci/plugins/gwt/GenericWebHookRequestReceiver.java

@@ -170,7 +170,8 @@ HttpResponse doInvoke(
       final String postContent,
       final String givenToken) {
 
-    final List<FoundJob> foundJobs = JobFinder.findAllJobsWithTrigger(givenToken);
+    final boolean useCache = this.shouldUseCache(parameterMap);
+    final List<FoundJob> foundJobs = JobFinder.findAllJobsWithTrigger(givenToken, useCache);
     final Map<String, Object> triggerResultsMap = new HashMap<>();
     boolean allSilent = true;
     boolean errors = false;
@@ -213,6 +214,21 @@ HttpResponse doInvoke(
     }
   }
 
+  private boolean shouldUseCache(final Map<String, String[]> parameterMap) {
+    if (parameterMap == null) {
+      return false;
+    }
+    final String useCacheParamName = "usecache";
+    if (parameterMap.containsKey(useCacheParamName)) {
+      final String[] useCache = parameterMap.get(useCacheParamName);
+      if (useCache.length == 1) {
+        final String useCacheValue = useCache[0];
+        return useCacheValue != null && (useCacheValue.equalsIgnoreCase("true"));
+      }
+    }
+    return false;
+  }
+
   String createMessageFromException(final Throwable t) {
     String stacktraceInfo = "";
     if (t.getStackTrace().length > 0) {

src/main/java/org/jenkinsci/plugins/gwt/jobfinder/JobFinder.java

@@ -22,7 +22,7 @@
 
 public final class JobFinder {
 
-  private static Logger LOG = Logger.getLogger(JobFinder.class.getSimpleName());
+  private static Logger LOG = Logger.getLogger(JobFinder.class.getName());
 
   private JobFinder() {}
 
@@ -33,13 +33,14 @@ static void setJobFinderImpersonater(final JobFinderImpersonater jobFinderImpers
     JobFinder.jobFinderImpersonater = jobFinderImpersonater;
   }
 
-  public static List<FoundJob> findAllJobsWithTrigger(final String givenToken) {
+  public static List<FoundJob> findAllJobsWithTrigger(
+      final String givenToken, final boolean useCache) {
 
     final List<FoundJob> found = new ArrayList<>();
 
     final boolean impersonate = !isNullOrEmpty(givenToken);
     final List<ParameterizedJob> candidateProjects =
-        jobFinderImpersonater.getAllParameterizedJobs(impersonate);
+        jobFinderImpersonater.getAllParameterizedJobs(impersonate, useCache);
     for (final ParameterizedJob candidateJob : candidateProjects) {
       final GenericTrigger genericTriggerOpt = findGenericTrigger(candidateJob.getTriggers());
       if (genericTriggerOpt != null) {

src/main/java/org/jenkinsci/plugins/gwt/jobfinder/JobFinderImpersonater.java

@@ -1,14 +1,77 @@
 package org.jenkinsci.plugins.gwt.jobfinder;
 
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
 import hudson.security.ACL;
+import java.time.Duration;
 import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import jenkins.model.Jenkins;
 import jenkins.model.ParameterizedJobMixIn.ParameterizedJob;
 import org.acegisecurity.context.SecurityContext;
 import org.acegisecurity.context.SecurityContextHolder;
 
 public class JobFinderImpersonater {
-  public List<ParameterizedJob> getAllParameterizedJobs(boolean impersonate) {
+  private static Logger LOGGER = Logger.getLogger(JobFinderImpersonater.class.getName());
+
+  private static final int CACHE_MINUTES = 15;
+  private static final int CACHE_REFRESH_INITIAL_DELAY = 0;
+  private static final int CACHE_REFRESH_DURATION = CACHE_MINUTES - 1;
+
+  private final ScheduledExecutorService newSingleThreadScheduledExecutor;
+  private final LoadingCache<Boolean, List<ParameterizedJob>> cache;
+
+  public JobFinderImpersonater() {
+    this.cache =
+        CacheBuilder.newBuilder() //
+            .refreshAfterWrite(Duration.ofMinutes(CACHE_MINUTES)) //
+            .build(
+                new CacheLoader<Boolean, List<ParameterizedJob>>() {
+                  @Override
+                  public List<ParameterizedJob> load(final Boolean impersonate) throws Exception {
+                    LOGGER.log(Level.FINE, "Loading the cache with impersonate " + impersonate);
+                    return doGetAllParameterizedJobs(impersonate);
+                  }
+                });
+    this.newSingleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
+    this.newSingleThreadScheduledExecutor.scheduleWithFixedDelay(
+        () -> {
+          LOGGER.log(Level.FINE, "Triggering cache refresh");
+          this.cache.asMap().keySet().parallelStream().forEach((key) -> this.cache.refresh(key));
+        },
+        CACHE_REFRESH_INITIAL_DELAY,
+        CACHE_REFRESH_DURATION,
+        TimeUnit.MINUTES);
+  }
+
+  public List<ParameterizedJob> getAllParameterizedJobs(
+      final boolean impersonate, final boolean useCache) {
+    if (useCache && impersonate) {
+      try {
+        LOGGER.log(Level.FINE, "Using the cache");
+        return this.cache.get(impersonate);
+      } catch (final ExecutionException e) {
+        LOGGER.log(Level.SEVERE, "Was unable to getAllParameterizedJobs from cache.", e);
+        return doGetAllParameterizedJobs(impersonate);
+      }
+    } else if (useCache && !impersonate) {
+      LOGGER.log(
+          Level.INFO,
+          "Not using the cache because jobs are not retreieved with impersonation SYSTEM. "
+              + "SYSTEM is only impersonated when using a token."
+              + " If SYSTEM is not impersonated, only jobs available for the currently authenticated user is found.");
+    }
+    LOGGER.log(Level.FINE, "Not using the cache");
+    return doGetAllParameterizedJobs(impersonate);
+  }
+
+  private static List<ParameterizedJob> doGetAllParameterizedJobs(final boolean impersonate) {
     SecurityContext orig = null;
     try {
       if (impersonate) {

src/test/java/org/jenkinsci/plugins/gwt/jobfinder/JobFinderTest.java

@@ -37,7 +37,8 @@ public void before() {
     final JobFinderImpersonater jobFinderImpersonater =
         new JobFinderImpersonater() {
           @Override
-          public List<ParameterizedJob> getAllParameterizedJobs(final boolean impersonate) {
+          public List<ParameterizedJob> getAllParameterizedJobs(
+              final boolean impersonate, final boolean usecache) {
             JobFinderTest.this.didImpersonate = impersonate;
             return JobFinderTest.this.allParameterizedJobsByImpersonation;
           }
@@ -71,7 +72,7 @@ private ParameterizedJob createJob(final String authToken, final String genericT
   }
 
   private List<String> findAllJobs(final String givenToken) {
-    final List<FoundJob> foundJobs = JobFinder.findAllJobsWithTrigger(givenToken);
+    final List<FoundJob> foundJobs = JobFinder.findAllJobsWithTrigger(givenToken, false);
     final List<String> names = new ArrayList<>();
     for (final FoundJob found : foundJobs) {
       names.add(found.getFullName());