KubernetesWatchTask Prerequisite refactor in JKube Kit

gradle-plugin/kubernetes/src/main/java/org/eclipse/jkube/gradle/plugin/task/AbstractJKubeTask.java

@@ -131,8 +131,7 @@ protected GeneratorContext.GeneratorContextBuilder initGeneratorContextBuilder()
         .project(kubernetesExtension.javaProject)
         .logger(kitLogger)
         .runtimeMode(kubernetesExtension.getRuntimeMode())
-        .useProjectClasspath(kubernetesExtension.getUseProjectClassPathOrDefault())
-        .artifactResolver(jKubeServiceHub.getArtifactResolverService());
+        .useProjectClasspath(kubernetesExtension.getUseProjectClassPathOrDefault());
   }
 
   protected ClusterConfiguration initClusterConfiguration() {

jkube-kit/common-maven/src/main/java/org/eclipse/jkube/kit/common/util/MavenUtil.java

@@ -174,7 +174,7 @@ public static List<Dependency> getDependencies(MavenProject project) {
     return project.getDependencies().stream()
         .map(d -> Dependency.builder()
             .groupId(d.getGroupId()).artifactId(d.getArtifactId()).version(d.getVersion()).type(d.getType())
-            .scope(d.getScope()).build())
+            .scope(d.getScope()).file(getArtifactFileFromArtifactMap(project, d)).build())
         .collect(Collectors.toList());
   }
 
@@ -418,5 +418,13 @@ public static File getRootProjectFolder(MavenProject project) {
         }
         return answer;
     }
+
+    private static File getArtifactFileFromArtifactMap(MavenProject mavenProject, org.apache.maven.model.Dependency dependency) {
+        Artifact artifact = mavenProject.getArtifactMap().get(dependency.getGroupId() + ":" + dependency.getArtifactId());
+        if (artifact != null) {
+            return artifact.getFile();
+        }
+        return null;
+    }
 }
 

jkube-kit/common-maven/src/test/java/org/eclipse/jkube/kit/common/util/SpringBootUtilTest.java

@@ -13,8 +13,12 @@
  */
 package org.eclipse.jkube.kit.common.util;
 
+import java.util.Collections;
+import java.util.Map;
 import java.util.Properties;
 
+import org.eclipse.jkube.kit.common.JavaProject;
+import org.eclipse.jkube.kit.common.Plugin;
 import org.junit.Test;
 
 import static junit.framework.TestCase.assertNull;
@@ -74,4 +78,42 @@ public void testMultipleProfilesParsing() {
         assertNull(props.get("spring.application.name"));
     }
 
+    @Test
+    public void getSpringBootPluginConfiguration_whenSpringBootMavenPluginPresent_thenReturnsPluginConfiguration() {
+        // Given
+        JavaProject javaProject = JavaProject.builder()
+            .plugin(Plugin.builder()
+                .groupId("org.springframework.boot")
+                .artifactId("spring-boot-maven-plugin")
+                .configuration(Collections.singletonMap("layout", "ZIP"))
+                .build())
+            .build();
+
+        // When
+        Map<String, Object> configuration = SpringBootUtil.getSpringBootPluginConfiguration(javaProject);
+
+        // Then
+        assertNotNull(configuration);
+        assertEquals("ZIP", configuration.get("layout").toString());
+    }
+
+    @Test
+    public void getSpringBootPluginConfiguration_whenSpringBootGradlePluginPresent_thenReturnsPluginConfiguration() {
+        // Given
+        JavaProject javaProject = JavaProject.builder()
+            .plugin(Plugin.builder()
+                .groupId("org.springframework.boot")
+                .artifactId("org.springframework.boot.gradle.plugin")
+                .configuration(Collections.singletonMap("mainClass", "com.example.ExampleApplication"))
+                .build())
+            .build();
+
+        // When
+        Map<String, Object> configuration = SpringBootUtil.getSpringBootPluginConfiguration(javaProject);
+
+        // Then
+        assertNotNull(configuration);
+        assertEquals("com.example.ExampleApplication", configuration.get("mainClass").toString());
+    }
+
 }

jkube-kit/common/src/main/java/org/eclipse/jkube/kit/common/util/JKubeProjectUtil.java

@@ -177,4 +177,19 @@ public static String getProperty(String key, JavaProject project) {
     }
     return value;
   }
+
+  public static File resolveArtifact(JavaProject project, String groupId, String artifactId, String version, String type) {
+    File artifact = project.getDependencies().stream()
+        .filter(d -> d.getGroupId().equals(groupId)
+            && d.getArtifactId().equals(artifactId)
+            && d.getVersion().equals(version)
+            && d.getType().equals(type))
+        .findFirst()
+        .map(Dependency::getFile)
+        .orElse(null);
+    if (artifact == null) {
+      throw new IllegalStateException("Cannot find artifact " + String.format("%s-%s.%s", artifactId, version, type) + " within the resolved resources");
+    }
+    return artifact;
+  }
 }

jkube-kit/common/src/main/java/org/eclipse/jkube/kit/common/util/SpringBootUtil.java

@@ -15,10 +15,13 @@
 
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.Collections;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Properties;
 
 import org.eclipse.jkube.kit.common.JavaProject;
+import org.eclipse.jkube.kit.common.Plugin;
 
 import static org.eclipse.jkube.kit.common.util.PropertiesUtil.getPropertiesFromResource;
 
@@ -88,5 +91,17 @@ public static String getSpringBootActiveProfile(JavaProject project) {
         }
         return null;
     }
+
+    public static Map<String, Object> getSpringBootPluginConfiguration(JavaProject javaProject) {
+        Plugin mavenPlugin = JKubeProjectUtil.getPlugin(javaProject, SpringBootConfigurationHelper.SPRING_BOOT_MAVEN_PLUGIN_ARTIFACT_ID);
+        if (mavenPlugin != null) {
+            return mavenPlugin.getConfiguration();
+        }
+        Plugin gradlePlugin = JKubeProjectUtil.getPlugin(javaProject, SpringBootConfigurationHelper.SPRING_BOOT_GRADLE_PLUGIN_ARTIFACT_ID);
+        if (gradlePlugin != null) {
+            return gradlePlugin.getConfiguration();
+        }
+        return Collections.emptyMap();
+    }
 }
 

jkube-kit/common/src/test/java/org/eclipse/jkube/kit/common/util/JKubeProjectUtilTest.java

@@ -19,6 +19,7 @@
 import org.eclipse.jkube.kit.common.Dependency;
 import org.eclipse.jkube.kit.common.JavaProject;
 import org.eclipse.jkube.kit.common.SystemMock;
+import org.junit.Assert;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
@@ -199,4 +200,38 @@ public void getProperty_whenProjectPropertyPresent_returnsProjectProperty() {
     // Then
     assertThat(result).isEqualTo("true");
   }
+
+  @Test
+  public void resolveArtifact_whenArtifactPresent_shouldReturnArtifact() {
+    // Given
+    File actualArtifact = new File(temporaryFolder.getRoot(), "test-artifact-0.0.1.jar");
+    JavaProject javaProject = JavaProject.builder()
+        .dependency(Dependency.builder()
+            .groupId("org.example")
+            .artifactId("test-artifact")
+            .version("0.0.1")
+            .type("jar")
+            .file(actualArtifact)
+            .build())
+        .build();
+
+    // When
+    File resolvedArtifact = JKubeProjectUtil.resolveArtifact(javaProject, "org.example", "test-artifact", "0.0.1", "jar");
+
+    // Then
+    assertThat(resolvedArtifact).isNotNull().isEqualTo(actualArtifact);
+  }
+
+  @Test
+  public void resolveArtifact_whenNoArtifactPresent_shouldThrowException() {
+    // Given
+    JavaProject javaProject = JavaProject.builder().build();
+
+    // When
+    IllegalStateException illegalStateException = Assert.assertThrows(IllegalStateException.class,
+        () -> JKubeProjectUtil.resolveArtifact(javaProject, "org.example", "test-artifact", "0.0.1", "jar"));
+
+    // Then
+    assertThat(illegalStateException).hasMessage("Cannot find artifact test-artifact-0.0.1.jar within the resolved resources");
+  }
 }

jkube-kit/config/service/src/main/java/org/eclipse/jkube/kit/config/service/JKubeServiceHub.java

@@ -25,7 +25,6 @@
 import org.eclipse.jkube.kit.common.service.MigrateService;
 import org.eclipse.jkube.kit.build.service.docker.ServiceHub;
 import org.eclipse.jkube.kit.common.KitLogger;
-import org.eclipse.jkube.kit.common.service.ArtifactResolverService;
 import org.eclipse.jkube.kit.common.util.LazyBuilder;
 import org.eclipse.jkube.kit.config.access.ClusterAccess;
 import org.eclipse.jkube.kit.config.access.ClusterConfiguration;
@@ -58,7 +57,6 @@ public class JKubeServiceHub implements Closeable {
     private BuildServiceConfig buildServiceConfig;
     @Getter
     private KubernetesClient client;
-    private LazyBuilder<ArtifactResolverService> artifactResolverService;
     private LazyBuilder<BuildServiceManager> buildServiceManager;
     private LazyBuilder<ResourceService> resourceService;
     private LazyBuilder<PortForwardService> portForwardService;
@@ -104,10 +102,6 @@ public RuntimeMode getRuntimeMode() {
         return platformMode;
     }
 
-    public ArtifactResolverService getArtifactResolverService() {
-        return artifactResolverService.get();
-    }
-
     public BuildService getBuildService() {
         return buildServiceManager.get().resolveBuildService();
     }
@@ -148,7 +142,6 @@ private void initClusterAccessAndLazyBuilders() {
             }
             this.client = clusterAccess.createDefaultClient();
         }
-        artifactResolverService = new LazyBuilder<>(() -> new JKubeArtifactResolverService(configuration.getProject()));
         buildServiceManager = new LazyBuilder<>(() -> new BuildServiceManager(this));
         applyService = new LazyBuilder<>(() -> {
             validateIfConnectedToCluster();

jkube-kit/config/service/src/test/java/org/eclipse/jkube/kit/config/service/JKubeServiceHubTest.java

@@ -137,15 +137,6 @@ public void testGetBuildServiceInOpenShift() {
         .isInstanceOf(OpenshiftBuildService.class);
   }
 
-  @Test
-  public void testGetArtifactResolverService() {
-    JKubeServiceHub hub = commonInit()
-            .platformMode(RuntimeMode.KUBERNETES)
-            .build();
-
-    assertThat(hub.getArtifactResolverService()).isNotNull();
-  }
-
   @Test
   public void testGetJibBuildServiceInKubernetes() {
     // Given

jkube-kit/generator/api/src/main/java/org/eclipse/jkube/generator/api/GeneratorContext.java

@@ -21,7 +21,6 @@
 import lombok.NoArgsConstructor;
 import org.eclipse.jkube.kit.common.JavaProject;
 import org.eclipse.jkube.kit.common.KitLogger;
-import org.eclipse.jkube.kit.common.service.ArtifactResolverService;
 import org.eclipse.jkube.kit.config.image.build.JKubeBuildStrategy;
 import org.eclipse.jkube.kit.config.resource.RuntimeMode;
 import org.eclipse.jkube.kit.config.resource.ProcessorConfig;
@@ -45,7 +44,6 @@ public class GeneratorContext {
 
     private boolean useProjectClasspath;
     private boolean prePackagePhase;
-    private ArtifactResolverService artifactResolver;
 
     private GeneratorMode generatorMode;
 

jkube-kit/jkube-kit-spring-boot/src/main/java/org/eclipse/jkube/springboot/generator/SpringBootGenerator.java

@@ -293,8 +293,7 @@ private boolean isSpringBootRepackage() {
     private File getSpringBootDevToolsJar() {
         String version = SpringBootUtil.getSpringBootDevToolsVersion(getProject())
             .orElseThrow(() -> new IllegalStateException("Unable to find the spring-boot version"));
-        final File devToolsJar = getContext().getArtifactResolver()
-            .resolveArtifact(SPRING_BOOT_GROUP_ID, SPRING_BOOT_DEVTOOLS_ARTIFACT_ID, version, "jar");
+        final File devToolsJar = JKubeProjectUtil.resolveArtifact(getProject(), SPRING_BOOT_GROUP_ID, SPRING_BOOT_DEVTOOLS_ARTIFACT_ID, version, "jar");
         if (!devToolsJar.exists()) {
             throw new IllegalArgumentException("devtools need to be included in repacked archive, please set <excludeDevtools> to false in plugin configuration");
         }

jkube-kit/jkube-kit-spring-boot/src/main/java/org/eclipse/jkube/springboot/watcher/SpringBootWatcher.java

@@ -54,6 +54,7 @@
 import org.apache.commons.lang3.StringUtils;
 
 import static org.eclipse.jkube.kit.common.util.SpringBootConfigurationHelper.DEV_TOOLS_REMOTE_SECRET;
+import static org.eclipse.jkube.kit.common.util.SpringBootUtil.getSpringBootPluginConfiguration;
 
 public class SpringBootWatcher extends BaseWatcher {
 
@@ -79,8 +80,8 @@ public SpringBootWatcher(WatcherContext watcherContext) {
 
     @Override
     public boolean isApplicable(List<ImageConfiguration> configs, Collection<HasMetadata> resources, PlatformMode mode) {
-        return JKubeProjectUtil.hasPluginOfAnyArtifactId(getContext().getBuildContext().getProject(),
-            SpringBootConfigurationHelper.SPRING_BOOT_MAVEN_PLUGIN_ARTIFACT_ID);
+        return JKubeProjectUtil.hasPluginOfAnyArtifactId(getContext().getBuildContext().getProject(), SpringBootConfigurationHelper.SPRING_BOOT_MAVEN_PLUGIN_ARTIFACT_ID) ||
+         JKubeProjectUtil.hasPluginOfAnyArtifactId(getContext().getBuildContext().getProject(), SpringBootConfigurationHelper.SPRING_BOOT_GRADLE_PLUGIN_ARTIFACT_ID);
     }
 
     @Override
@@ -259,14 +260,12 @@ public void run() {
 
     private File getSpringBootDevToolsJar(JavaProject project) {
         String version = SpringBootUtil.getSpringBootDevToolsVersion(project).orElseThrow(() -> new IllegalStateException("Unable to find the spring-boot version"));
-        return getContext().getJKubeServiceHub().getArtifactResolverService().resolveArtifact(SpringBootConfigurationHelper.SPRING_BOOT_GROUP_ID, SpringBootConfigurationHelper.SPRING_BOOT_DEVTOOLS_ARTIFACT_ID, version, "jar");
+        return JKubeProjectUtil.resolveArtifact(getContext().getBuildContext().getProject(), SpringBootConfigurationHelper.SPRING_BOOT_GROUP_ID, SpringBootConfigurationHelper.SPRING_BOOT_DEVTOOLS_ARTIFACT_ID, version, "jar");
     }
 
     private String validateSpringBootDevtoolsSettings() {
-        final Map<String, Object> configuration = JKubeProjectUtil
-            .getPlugin(getContext().getBuildContext().getProject(), SpringBootConfigurationHelper.SPRING_BOOT_MAVEN_PLUGIN_ARTIFACT_ID)
-            .getConfiguration();
-        if(!configuration.containsKey("excludeDevtools") || !configuration.get("excludeDevtools").equals("false")) {
+        final Map<String, Object> configuration = getSpringBootPluginConfiguration(getContext().getBuildContext().getProject());
+        if(configuration != null && (!configuration.containsKey("excludeDevtools") || !configuration.get("excludeDevtools").equals("false"))) {
             log.warn("devtools need to be included in repacked archive, please set <excludeDevtools> to false in plugin configuration");
             throw new IllegalStateException("devtools needs to be included in fat jar");
         }