Infer main class if it isn't configured anywhere

jib-core/src/main/java/com/google/cloud/tools/jib/frontend/MainClassFinder.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.cloud.tools.jib.frontend;
+
+import com.google.cloud.tools.jib.filesystem.DirectoryWalker;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringJoiner;
+import javax.annotation.Nullable;
+
+/** Infers the main class in an application. */
+public class MainClassFinder {
+
+  /** Helper for loading a .class file. */
+  private static class ClassFileLoader extends ClassLoader {
+
+    private final Path classFile;
+
+    private ClassFileLoader(Path classFile) {
+      this.classFile = classFile;
+    }
+
+    @Nullable
+    @Override
+    public Class findClass(String name) {
+      try {
+        byte[] bytes = Files.readAllBytes(classFile);
+        return defineClass(name, bytes, 0, bytes.length);
+      } catch (IOException | ClassFormatError ignored) {
+        // Not a valid class file
+        return null;
+      }
+    }
+  }
+
+  /**
+   * Searches for a .class file containing a main method given an absolute root directory.
+   *
+   * @return the name of the class if one is found, null if no class is found.
+   * @throws IOException if searching/reading files fails.
+   */
+  public static List<String> findMainClass(Path rootDirectory) throws IOException {
+    List<String> results = new ArrayList<>();
+
+    // Make sure rootDirectory is valid
+    if (!Files.exists(rootDirectory) || !Files.isDirectory(rootDirectory)) {
+      return results;
+    }
+
+    // Get all .class files
+    new DirectoryWalker(rootDirectory)
+        .filter(Files::isRegularFile)
+        .filter(path -> path.toString().endsWith(".class"))
+        .walk(
+            classFile -> {
+              // Convert filename (rootDir/path/to/ClassName.class) to class name
+              // (path.to.ClassName)
+              Path relativized = rootDirectory.relativize(classFile);
+              StringJoiner stringJoiner = new StringJoiner(".");
+              for (Path path : relativized) {
+                stringJoiner.add(path.toString());
+              }
+              String name = stringJoiner.toString();
+              name = name.substring(0, name.length() - ".class".length());
+
+              Class<?> fileClass = new ClassFileLoader(classFile).findClass(name);
+              if (fileClass != null) {
+                try {
+                  // Check if class contains {@code public static void main(String[] args)}
+                  Method main = fileClass.getMethod("main", String[].class);
+                  if (main != null
+                      && main.getReturnType() == void.class
+                      && Modifier.isStatic(main.getModifiers())
+                      && Modifier.isPublic(main.getModifiers())) {
+                    results.add(name);
+                  }
+                } catch (NoSuchMethodException ignored) {
+                  // main method not found
+                }
+              }
+            });
+
+    return results;
+  }
+
+  private MainClassFinder() {}
+}

jib-core/src/test/java/com/google/cloud/tools/jib/frontend/MainClassFinderTest.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.cloud.tools.jib.frontend;
+
+import com.google.common.io.Resources;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.Test;
+
+/** Test for MainClassFinder. */
+public class MainClassFinderTest {
+
+  @Test
+  public void testFindMainClass_simple() throws URISyntaxException, IOException {
+    Path rootDirectory = Paths.get(Resources.getResource("class-finder-tests/simple").toURI());
+    List<String> mainClasses = MainClassFinder.findMainClass(rootDirectory);
+    Assert.assertEquals(1, mainClasses.size());
+    Assert.assertTrue(mainClasses.contains("HelloWorld"));
+  }
+
+  @Test
+  public void testFindMainClass_subdirectories() throws URISyntaxException, IOException {
+    Path rootDirectory =
+        Paths.get(Resources.getResource("class-finder-tests/subdirectories").toURI());
+    List<String> mainClasses = MainClassFinder.findMainClass(rootDirectory);
+    Assert.assertEquals(1, mainClasses.size());
+    Assert.assertTrue(mainClasses.contains("multi.layered.HelloWorld"));
+  }
+
+  @Test
+  public void testFindMainClass_noClass() throws URISyntaxException, IOException {
+    Path rootDirectory = Paths.get(Resources.getResource("class-finder-tests/no-main").toURI());
+    List<String> mainClasses = MainClassFinder.findMainClass(rootDirectory);
+    Assert.assertTrue(mainClasses.isEmpty());
+  }
+
+  @Test
+  public void testFindMainClass_multiple() throws URISyntaxException, IOException {
+    Path rootDirectory = Paths.get(Resources.getResource("class-finder-tests/multiple").toURI());
+    List<String> mainClasses = MainClassFinder.findMainClass(rootDirectory);
+    Assert.assertEquals(2, mainClasses.size());
+    Assert.assertTrue(mainClasses.contains("multi.layered.HelloMoon"));
+    Assert.assertTrue(mainClasses.contains("HelloWorld"));
+  }
+}

jib-core/src/test/resources/class-finder-tests/simple/NotEvenAClass.txt

@@ -0,0 +1 @@
+Hi there.

jib-gradle-plugin/src/integration-test/resources/projects/empty/build.gradle

@@ -15,7 +15,6 @@ jib {
         image = 'gcr.io/jib-integration-testing/emptyimage:gradle'
         credHelper = 'gcr'
     }
-    mainClass = 'com.test.Empty'
     // Does not have tests use user-level cache for base image layers.
     useOnlyProjectCache = true
 }

jib-gradle-plugin/src/integration-test/resources/projects/simple/build.gradle

@@ -19,7 +19,6 @@ jib {
         image = 'gcr.io/jib-integration-testing/simpleimage:gradle'
         credHelper = 'gcr'
     }
-    mainClass = 'com.test.HelloWorld'
     // Does not have tests use user-level cache for base image layers.
     useOnlyProjectCache = true
 }

jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/ProjectProperties.java

@@ -18,13 +18,18 @@
 
 import com.google.cloud.tools.jib.builder.BuildConfiguration;
 import com.google.cloud.tools.jib.builder.SourceFilesConfiguration;
+import com.google.cloud.tools.jib.frontend.MainClassFinder;
 import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 import javax.annotation.Nullable;
 import org.gradle.api.GradleException;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
+import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.tasks.SourceSet;
 import org.gradle.jvm.tasks.Jar;
 
 /** Obtains information about a Gradle {@link Project} that uses Jib. */
@@ -46,21 +51,45 @@ String getMainClass(@Nullable String mainClass) {
     if (mainClass == null) {
       mainClass = getMainClassFromJarTask();
       if (mainClass == null) {
-        throw new GradleException(
-            HelpfulSuggestionsProvider.get("Could not find main class specified in a 'jar' task")
-                .suggest("add a `mainClass` configuration to jib"));
+        gradleBuildLogger.debug(
+            "Could not find main class specified in a 'jar' task; attempting to "
+                + "infer main class.");
+
+        final String mainClassSuggestion = "add a `mainClass` configuration to jib";
+        try {
+          // Adds each file in each classes output directory to the classes files list.
+          JavaPluginConvention javaPluginConvention =
+              project.getConvention().getPlugin(JavaPluginConvention.class);
+          SourceSet mainSourceSet = javaPluginConvention.getSourceSets().getByName("main");
+          Path classesDirs = Paths.get(mainSourceSet.getOutput().getClassesDirs().getAsPath());
+          List<String> mainClasses = new ArrayList<>(MainClassFinder.findMainClass(classesDirs));
+
+          if (mainClasses.size() == 1) {
+            mainClass = mainClasses.get(0);
+          } else if (mainClasses.size() == 0) {
+            throw new GradleException(
+                HelpfulSuggestionsProvider.get("Main class was not found")
+                    .suggest(mainClassSuggestion));
+          } else {
+            throw new GradleException(
+                HelpfulSuggestionsProvider.get(
+                        "Multiple valid main classes were found: " + String.join(", ", mainClasses))
+                    .suggest(mainClassSuggestion));
+          }
+        } catch (IOException ex) {
+          throw new GradleException(
+              HelpfulSuggestionsProvider.get("Failed to get main class")
+                  .suggest(mainClassSuggestion),
+              ex);
+        }
       }
     }
     if (!BuildConfiguration.isValidJavaClass(mainClass)) {
-      getLogger().warn("'mainClass' is not a valid Java class : " + mainClass);
+      gradleBuildLogger.warn("'mainClass' is not a valid Java class : " + mainClass);
     }
     return mainClass;
   }
 
-  GradleBuildLogger getLogger() {
-    return gradleBuildLogger;
-  }
-
   /** @return the {@link SourceFilesConfiguration} based on the current project */
   SourceFilesConfiguration getSourceFilesConfiguration() {
     try {

jib-gradle-plugin/src/test/java/com/google/cloud/tools/jib/gradle/ProjectPropertiesTest.java

@@ -19,9 +19,15 @@
 import java.util.Collections;
 import org.gradle.api.GradleException;
 import org.gradle.api.Project;
+import org.gradle.api.file.FileCollection;
 import org.gradle.api.internal.file.FileResolver;
 import org.gradle.api.java.archives.Manifest;
 import org.gradle.api.java.archives.internal.DefaultManifest;
+import org.gradle.api.plugins.Convention;
+import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.SourceSetContainer;
+import org.gradle.api.tasks.SourceSetOutput;
 import org.gradle.internal.impldep.com.google.common.collect.ImmutableMap;
 import org.gradle.internal.impldep.com.google.common.collect.ImmutableSet;
 import org.gradle.jvm.tasks.Jar;
@@ -43,6 +49,13 @@ public class ProjectPropertiesTest {
   @Mock private Project mockProject;
   @Mock private GradleBuildLogger mockGradleBuildLogger;
 
+  @Mock private Convention mockConvention;
+  @Mock private JavaPluginConvention mockPluginConvention;
+  @Mock private SourceSetContainer mockSourceSetContainer;
+  @Mock private SourceSet mockSourceSet;
+  @Mock private SourceSetOutput mockSourceSetOutput;
+  @Mock private FileCollection mockFileCollection;
+
   private Manifest fakeManifest;
   private ProjectProperties testProjectProperties;
 
@@ -51,6 +64,15 @@ public void setUp() {
     fakeManifest = new DefaultManifest(mockFileResolver);
     Mockito.when(mockJar.getManifest()).thenReturn(fakeManifest);
 
+    Mockito.when(mockProject.getConvention()).thenReturn(mockConvention);
+    Mockito.when(mockConvention.getPlugin(JavaPluginConvention.class))
+        .thenReturn(mockPluginConvention);
+    Mockito.when(mockPluginConvention.getSourceSets()).thenReturn(mockSourceSetContainer);
+    Mockito.when(mockSourceSetContainer.getByName("main")).thenReturn(mockSourceSet);
+    Mockito.when(mockSourceSet.getOutput()).thenReturn(mockSourceSetOutput);
+    Mockito.when(mockSourceSetOutput.getClassesDirs()).thenReturn(mockFileCollection);
+    Mockito.when(mockFileCollection.getAsPath()).thenReturn("a/b/c");
+
     testProjectProperties = new ProjectProperties(mockProject, mockGradleBuildLogger);
   }
 
@@ -95,9 +117,9 @@ private void assertGetMainClassFails() {
       Assert.fail("Main class not expected");
 
     } catch (GradleException ex) {
-      Assert.assertThat(
-          ex.getMessage(),
-          CoreMatchers.containsString("Could not find main class specified in a 'jar' task"));
+      Mockito.verify(mockGradleBuildLogger)
+          .debug(
+              "Could not find main class specified in a 'jar' task; attempting to infer main class.");
       Assert.assertThat(
           ex.getMessage(), CoreMatchers.containsString("add a `mainClass` configuration to jib"));
     }

jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/ProjectProperties.java

@@ -18,8 +18,11 @@
 
 import com.google.cloud.tools.jib.builder.BuildConfiguration;
 import com.google.cloud.tools.jib.builder.SourceFilesConfiguration;
+import com.google.cloud.tools.jib.frontend.MainClassFinder;
 import com.google.common.base.Preconditions;
 import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.List;
 import javax.annotation.Nullable;
 import org.apache.maven.model.Plugin;
 import org.apache.maven.plugin.MojoExecutionException;
@@ -57,10 +60,32 @@ String getMainClass(@Nullable String mainClass) throws MojoExecutionException {
     if (mainClass == null) {
       mainClass = getMainClassFromMavenJarPlugin();
       if (mainClass == null) {
-        throw new MojoExecutionException(
-            HelpfulSuggestionsProvider.get(
-                    "Could not find main class specified in maven-jar-plugin")
-                .suggest("add a `mainClass` configuration to jib-maven-plugin"));
+        log.debug(
+            "Could not find main class specified in maven-jar-plugin; attempting to infer main "
+                + "class.");
+
+        final String mainClassSuggestion = "add a `mainClass` configuration to jib-maven-plugin";
+        try {
+          List<String> mainClasses =
+              MainClassFinder.findMainClass(Paths.get(project.getBuild().getOutputDirectory()));
+          if (mainClasses.size() == 1) {
+            mainClass = mainClasses.get(0);
+          } else if (mainClasses.size() == 0) {
+            throw new MojoExecutionException(
+                HelpfulSuggestionsProvider.get("Main class was not found")
+                    .suggest(mainClassSuggestion));
+          } else {
+            throw new MojoExecutionException(
+                HelpfulSuggestionsProvider.get(
+                        "Multiple valid main classes were found: " + String.join(", ", mainClasses))
+                    .suggest(mainClassSuggestion));
+          }
+        } catch (IOException ex) {
+          throw new MojoExecutionException(
+              HelpfulSuggestionsProvider.get("Failed to get main class")
+                  .suggest(mainClassSuggestion),
+              ex);
+        }
       }
     }
     Preconditions.checkNotNull(mainClass);