Implement auto-injection of the Develocity npm agent

plugin/src/main/java/hudson/plugins/gradle/injection/ArtifactDigest.java

@@ -0,0 +1,3 @@
+package hudson.plugins.gradle.injection;
+
+public record ArtifactDigest(String digest) {}

plugin/src/main/java/hudson/plugins/gradle/injection/ArtifactMetadata.java

@@ -0,0 +1,38 @@
+package hudson.plugins.gradle.injection;
+
+import javax.annotation.Nullable;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Optional;
+
+public record ArtifactMetadata(String version, ArtifactDigest digest) {
+
+    private static final String SEPARATOR = ",";
+
+    // Adapter from the old interface
+    public ArtifactMetadata(String version, String digest) {
+        this(version, new ArtifactDigest(digest));
+    }
+
+    public boolean isForVersion(@Nullable String requiredVersion) {
+        return version.equals(requiredVersion);
+    }
+
+    public void writeToFile(Path metadataFile) throws IOException {
+        String content = version + SEPARATOR + digest.digest();
+        Files.writeString(metadataFile, content);
+    }
+
+    public static Optional<ArtifactMetadata> readFromFile(Path metadataFile) throws IOException {
+        if (Files.exists(metadataFile)) {
+            String[] metadata = Files.readString(metadataFile).split(SEPARATOR);
+            if (metadata.length == 2) {
+                String version = metadata[0];
+                ArtifactDigest digest = new ArtifactDigest(metadata[1]);
+                return Optional.of(new ArtifactMetadata(version, digest));
+            }
+        }
+        return Optional.empty();
+    }
+}

plugin/src/main/java/hudson/plugins/gradle/injection/BuildScanEnvironmentContributor.java

@@ -2,6 +2,7 @@
 
 import com.cloudbees.plugins.credentials.CredentialsProvider;
 import com.cloudbees.plugins.credentials.common.StandardUsernamePasswordCredentials;
+import com.google.common.annotations.VisibleForTesting;
 import hudson.EnvVars;
 import hudson.Extension;
 import hudson.model.EnvironmentContributor;
@@ -33,12 +34,13 @@ public class BuildScanEnvironmentContributor extends EnvironmentContributor {
 
     private final ShortLivedTokenClientFactory shortLivedTokenClientFactory;
 
+    @SuppressWarnings("unused")
     public BuildScanEnvironmentContributor() {
-        this.shortLivedTokenClientFactory = new ShortLivedTokenClientFactory();
+        this(new ShortLivedTokenClientFactory());
     }
 
-    // required for testing
-    public BuildScanEnvironmentContributor(ShortLivedTokenClientFactory shortLivedTokenClientFactory) {
+    @VisibleForTesting
+    BuildScanEnvironmentContributor(ShortLivedTokenClientFactory shortLivedTokenClientFactory) {
         this.shortLivedTokenClientFactory = shortLivedTokenClientFactory;
     }
 
@@ -67,10 +69,11 @@ public void buildEnvironmentFor(@Nonnull Run run, @Nonnull EnvVars envs, @Nonnul
 
         Secret shortLivedToken = getShortLivedToken(secretKey, logger);
 
-        run.addAction(DevelocityParametersAction.of(logger, shortLivedToken, secretPassword));
+        run.addAction(DevelocityParametersAction.of(shortLivedToken, secretPassword));
     }
 
-    private @Nullable Secret getShortLivedToken(Secret secretKey, DevelocityLogger logger) {
+    @Nullable
+    private Secret getShortLivedToken(Secret secretKey, DevelocityLogger logger) {
         if (secretKey == null) {
             return null;
         }
@@ -143,7 +146,7 @@ static DevelocityParametersAction empty() {
             return EMPTY;
         }
 
-        private static DevelocityParametersAction of(DevelocityLogger logger, @Nullable Secret shortLivedToken, @Nullable Secret repoPassword) {
+        private static DevelocityParametersAction of(@Nullable Secret shortLivedToken, @Nullable Secret repoPassword) {
             List<ParameterValue> values = new ArrayList<>();
             if (shortLivedToken != null) {
                 values.add(new PasswordParameterValue(GRADLE_ENTERPRISE_ACCESS_KEY, shortLivedToken.getPlainText()));

plugin/src/main/java/hudson/plugins/gradle/injection/CopyUtil.java

@@ -2,14 +2,9 @@
 
 import hudson.FilePath;
 import hudson.Util;
-import jenkins.model.Jenkins;
-import org.apache.commons.io.IOUtils;
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
 
 public final class CopyUtil {
 
@@ -24,7 +19,7 @@ public static void copyResourceToNode(FilePath nodePath, String resourceName) th
     }
 
     public static void copyDownloadedResourceToNode(FilePath controllerRootPath, FilePath nodePath, String resourceName) throws IOException, InterruptedException {
-        nodePath.copyFrom(controllerRootPath.child(MavenExtensionDownloadHandler.DOWNLOAD_CACHE_DIR).child(resourceName));
+        nodePath.copyFrom(controllerRootPath.child(InjectionUtil.DOWNLOAD_CACHE_DIR).child(resourceName));
     }
 
     public static String unsafeResourceDigest(String resourceName) {

plugin/src/main/java/hudson/plugins/gradle/injection/DevelocityComputerListener.java

@@ -29,6 +29,7 @@ public class DevelocityComputerListener extends ComputerListener {
     private final MavenExtensionDownloadHandler mavenExtensionDownloadHandler;
     private final Supplier<InjectionConfig> injectionConfigSupplier;
 
+    @SuppressWarnings("unused")
     public DevelocityComputerListener() {
         this(
                 new GradleBuildScanInjection(),

plugin/src/main/java/hudson/plugins/gradle/injection/DevelocityErrorsAction.java

@@ -23,8 +23,10 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+@SuppressWarnings("unused")
 @Extension
 public class DevelocityErrorsAction implements RootAction, StaplerProxy {
+
     @Override
     public String getIconFileName() {
         return isVisible() && Jenkins.get().hasPermission(Jenkins.ADMINISTER) ? "/plugin/gradle/images/svgs/gradle-build-scan.svg" : null;

plugin/src/main/java/hudson/plugins/gradle/injection/GitScmListener.java

@@ -26,6 +26,7 @@
 import static hudson.plugins.gradle.injection.MavenInjectionAware.MAVEN_OPTS_HANDLER;
 import static hudson.plugins.gradle.injection.MavenOptsHandler.MAVEN_OPTS;
 
+@SuppressWarnings("unused")
 @Extension
 public class GitScmListener extends SCMListener {
 

plugin/src/main/java/hudson/plugins/gradle/injection/GradleBuildScanInjection.java

@@ -18,7 +18,8 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
-import static hudson.plugins.gradle.injection.CopyUtil.*;
+import static hudson.plugins.gradle.injection.CopyUtil.copyResourceToNode;
+import static hudson.plugins.gradle.injection.CopyUtil.unsafeResourceDigest;
 
 public class GradleBuildScanInjection implements GradleInjectionAware {
 
@@ -64,14 +65,16 @@ private static String getInitScriptDirectory(EnvVars envGlobal, EnvVars envCompu
 
         if (gradleHomeOverride != null) {
             return filePath(gradleHomeOverride, INIT_DIR);
-        } else if (homeOverride != null) {
-            return filePath(homeOverride, GRADLE_DIR, INIT_DIR);
-        } else {
-            String home = EnvUtil.getEnv(envComputer, HOME);
-            Preconditions.checkState(home != null, "HOME is not set");
+        }
 
-            return filePath(home, GRADLE_DIR, INIT_DIR);
+        if (homeOverride != null) {
+            return filePath(homeOverride, GRADLE_DIR, INIT_DIR);
         }
+
+        String home = EnvUtil.getEnv(envComputer, HOME);
+        Preconditions.checkState(home != null, "HOME is not set");
+
+        return filePath(home, GRADLE_DIR, INIT_DIR);
     }
 
     private void inject(InjectionConfig config, Node node, String initScriptDirectory) {
@@ -184,5 +187,4 @@ private static String getRepositoryUsername(String gradlePluginRepositoryCredent
     private static String filePath(String... parts) {
         return String.join("/", parts);
     }
-
 }

plugin/src/main/java/hudson/plugins/gradle/injection/GradleInjectionAware.java

@@ -1,40 +1,25 @@
 package hudson.plugins.gradle.injection;
 
-import hudson.model.Node;
-import hudson.plugins.gradle.util.CollectionUtil;
+import javax.annotation.Nullable;
+import java.util.List;
 
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
+public interface GradleInjectionAware extends InjectionAware {
 
-public interface GradleInjectionAware {
-
-    default boolean isInjectionDisabledGlobally(InjectionConfig config) {
-        return config.isDisabled() ||
-                InjectionUtil.isAnyInvalid(
-                        InjectionConfig.checkRequiredUrl(config.getServer()),
-                        InjectionConfig.checkRequiredVersion(config.getGradlePluginVersion())
-                );
+    @Nullable
+    @Override
+    default String getAgentVersion(InjectionConfig config) {
+        return config.getGradlePluginVersion();
     }
 
-    default boolean isInjectionEnabledForNode(InjectionConfig config, Node node) {
-        if (isInjectionDisabledGlobally(config)) {
-            return false;
-        }
-
-        Set<String> disabledNodes =
-                CollectionUtil.safeStream(config.getGradleInjectionDisabledNodes())
-                        .map(NodeLabelItem::getLabel)
-                        .filter(Objects::nonNull)
-                        .collect(Collectors.toSet());
-
-        Set<String> enabledNodes =
-                CollectionUtil.safeStream(config.getGradleInjectionEnabledNodes())
-                        .map(NodeLabelItem::getLabel)
-                        .filter(Objects::nonNull)
-                        .collect(Collectors.toSet());
-
-        return InjectionUtil.isInjectionEnabledForNode(node::getAssignedLabels, disabledNodes, enabledNodes);
+    @Nullable
+    @Override
+    default List<NodeLabelItem> getAgentInjectionDisabledNodes(InjectionConfig config) {
+        return config.getGradleInjectionDisabledNodes();
     }
 
+    @Nullable
+    @Override
+    default List<NodeLabelItem> getAgentInjectionEnabledNodes(InjectionConfig config) {
+        return config.getGradleInjectionEnabledNodes();
+    }
 }

plugin/src/main/java/hudson/plugins/gradle/injection/InitScriptVariables.java

@@ -24,15 +24,7 @@ public enum InitScriptVariables {
         this.templateName = templateName;
     }
 
-    String getTemplateName() {
-        return templateName;
-    }
-
     String getEnvVar() {
         return templateName.toUpperCase().replace('.', '_').replace('-', '_');
     }
-
-    String sysProp(String value) {
-        return "-D" + getTemplateName() + "=" + value;
-    }
 }

plugin/src/main/java/hudson/plugins/gradle/injection/InjectionAware.java

@@ -0,0 +1,50 @@
+package hudson.plugins.gradle.injection;
+
+import hudson.model.Node;
+import hudson.plugins.gradle.util.CollectionUtil;
+
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public interface InjectionAware {
+
+    @Nullable
+    String getAgentVersion(InjectionConfig config);
+
+    @Nullable
+    List<NodeLabelItem> getAgentInjectionDisabledNodes(InjectionConfig config);
+
+    @Nullable
+    List<NodeLabelItem> getAgentInjectionEnabledNodes(InjectionConfig config);
+
+    default boolean isInjectionDisabledGlobally(InjectionConfig config) {
+        return config.isDisabled() ||
+                InjectionUtil.isAnyInvalid(
+                        InjectionConfig.checkRequiredUrl(config.getServer()),
+                        InjectionConfig.checkRequiredVersion(getAgentVersion(config))
+                );
+    }
+
+    default boolean isInjectionEnabledForNode(InjectionConfig config, Node node) {
+        if (isInjectionDisabledGlobally(config)) {
+            return false;
+        }
+
+        Set<String> disabledNodes =
+                CollectionUtil.safeStream(getAgentInjectionDisabledNodes(config))
+                        .map(NodeLabelItem::getLabel)
+                        .filter(Objects::nonNull)
+                        .collect(Collectors.toSet());
+
+        Set<String> enabledNodes =
+                CollectionUtil.safeStream(getAgentInjectionEnabledNodes(config))
+                        .map(NodeLabelItem::getLabel)
+                        .filter(Objects::nonNull)
+                        .collect(Collectors.toSet());
+
+        return InjectionUtil.isInjectionEnabledForNode(node::getAssignedLabels, disabledNodes, enabledNodes);
+    }
+}