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,115 @@
+/*
+ * 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 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.nio.file.Paths;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Nullable;
+
+/** Class used for inferring the main class in an application. */
+public class MainClassFinder {
+
+  /** Helper class for loading a .class file. */
+  private static class ClassFileLoader extends ClassLoader {
+
+    private 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 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.
+   * @throws MultipleClassesFoundException if more than one valid main class is found.
+   */
+  @Nullable
+  public static String findMainClass(String rootDirectory)
+      throws MultipleClassesFoundException, IOException {
+    // Make sure rootDirectory is valid
+    if (!Files.exists(Paths.get(rootDirectory)) || !Files.isDirectory(Paths.get(rootDirectory))) {
+      return null;
+    }
+
+    String className = null;
+    try (Stream<Path> pathStream = Files.walk(Paths.get(rootDirectory))) {
+      // Get all .class files
+      List<Path> classFiles =
+          pathStream
+              .filter(Files::isRegularFile)
+              .filter(path -> path.toString().endsWith(".class"))
+              .collect(Collectors.toList());
+
+      for (Path classFile : classFiles) {
+        // Convert filename (rootDir/path/to/ClassName.class) to class name (path.to.ClassName)
+        String name = classFile.toAbsolutePath().toString();
+        name = name.substring(rootDirectory.length() + 1);
+        name = name.replace('/', '.').replace('\\', '.');
+        name = name.substring(0, name.length() - ".class".length());
+
+        Class fileClass = new ClassFileLoader(classFile).findClass(name);
+        if (fileClass == null) {
+          // Got an invalid class file, keep searching
+          continue;
+        }
+
+        try {
+          // Check if class contains a 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())) {
+            if (className == null) {
+              // Main method found; save it and continue searching for duplicates
+              className = name;
+            } else {
+              // Found more than one main method
+              throw new MultipleClassesFoundException(className, name);
+            }
+          }
+        } catch (NoSuchMethodException ignored) {
+          // main method not found
+        }
+      }
+    }
+
+    return className;
+  }
+}

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

@@ -0,0 +1,27 @@
+/*
+ * 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;
+
+public class MultipleClassesFoundException extends Exception {
+  MultipleClassesFoundException(String className1, String className2) {
+    super(
+        "Multiple classes found while trying to infer main class: "
+            + className1
+            + ", "
+            + className2);
+  }
+}

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

@@ -0,0 +1,68 @@
+/*
+ * 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 org.junit.Assert;
+import org.junit.Test;
+
+/** Test for MainClassFinder. */
+public class MainClassFinderTest {
+
+  @Test
+  public void testFindMainClass_simple()
+      throws URISyntaxException, MultipleClassesFoundException, IOException {
+    Path rootDirectory = Paths.get(Resources.getResource("class-finder-tests/simple").toURI());
+    String mainClass = MainClassFinder.findMainClass(rootDirectory.toString());
+    Assert.assertEquals("HelloWorld", mainClass);
+  }
+
+  @Test
+  public void testFindMainClass_subdirectories()
+      throws URISyntaxException, MultipleClassesFoundException, IOException {
+    Path rootDirectory =
+        Paths.get(Resources.getResource("class-finder-tests/subdirectories").toURI());
+    String mainClass = MainClassFinder.findMainClass(rootDirectory.toString());
+    Assert.assertEquals("multi.layered.HelloWorld", mainClass);
+  }
+
+  @Test
+  public void testFindMainClass_noClass()
+      throws URISyntaxException, MultipleClassesFoundException, IOException {
+    Path rootDirectory = Paths.get(Resources.getResource("class-finder-tests/no-main").toURI());
+    String mainClass = MainClassFinder.findMainClass(rootDirectory.toString());
+    Assert.assertEquals(null, mainClass);
+  }
+
+  @Test
+  public void testFindMainClass_multiple() throws URISyntaxException, IOException {
+    Path rootDirectory = Paths.get(Resources.getResource("class-finder-tests/multiple").toURI());
+    try {
+      MainClassFinder.findMainClass(rootDirectory.toString());
+      Assert.fail();
+    } catch (MultipleClassesFoundException ex) {
+      Assert.assertTrue(
+          ex.getMessage().contains("Multiple classes found while trying to infer main class: "));
+      Assert.assertTrue(ex.getMessage().contains("multi.layered.HelloMoon"));
+      Assert.assertTrue(ex.getMessage().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,6 +18,8 @@
 
 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.cloud.tools.jib.frontend.MultipleClassesFoundException;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
@@ -46,9 +48,31 @@ 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"));
+        getLogger()
+            .info(
+                "Could not find main class specified in a 'jar' task; attempting to "
+                    + "infer main class.");
+        try {
+          mainClass =
+              MainClassFinder.findMainClass(
+                  project
+                      .getBuildDir()
+                      .toPath()
+                      .resolve("classes")
+                      .resolve("java")
+                      .resolve("main")
+                      .toAbsolutePath()
+                      .toString());
+        } catch (MultipleClassesFoundException | IOException ex) {
+          throw new GradleException(
+              HelpfulSuggestionsProvider.get("Failed to get main class: " + ex.getMessage())
+                  .suggest("add a `mainClass` configuration to jib"));
+        }
+        if (mainClass == null) {
+          throw new GradleException(
+              HelpfulSuggestionsProvider.get("Could not infer main class")
+                  .suggest("add a `mainClass` configuration to jib"));
+        }
       }
     }
     if (!BuildConfiguration.isValidJavaClass(mainClass)) {
@@ -57,7 +81,7 @@ String getMainClass(@Nullable String mainClass) {
     return mainClass;
   }
 
-  GradleBuildLogger getLogger() {
+  private GradleBuildLogger getLogger() {
     return gradleBuildLogger;
   }
 

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

@@ -16,6 +16,8 @@
 
 package com.google.cloud.tools.jib.gradle;
 
+import java.io.File;
+import java.io.IOException;
 import java.util.Collections;
 import org.gradle.api.GradleException;
 import org.gradle.api.Project;
@@ -28,7 +30,9 @@
 import org.hamcrest.CoreMatchers;
 import org.junit.Assert;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.Mockito;
@@ -38,6 +42,8 @@
 @RunWith(MockitoJUnitRunner.class)
 public class ProjectPropertiesTest {
 
+  @Rule public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
   @Mock private FileResolver mockFileResolver;
   @Mock private Jar mockJar;
   @Mock private Project mockProject;
@@ -47,10 +53,13 @@ public class ProjectPropertiesTest {
   private ProjectProperties testProjectProperties;
 
   @Before
-  public void setUp() {
+  public void setUp() throws IOException {
     fakeManifest = new DefaultManifest(mockFileResolver);
     Mockito.when(mockJar.getManifest()).thenReturn(fakeManifest);
 
+    File tempFolder = temporaryFolder.newFolder();
+    Mockito.when(mockProject.getBuildDir()).thenReturn(tempFolder);
+
     testProjectProperties = new ProjectProperties(mockProject, mockGradleBuildLogger);
   }
 
@@ -95,9 +104,10 @@ 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)
+          .info(
+              "Could not find main class specified in a 'jar' task; attempting to infer main class.");
+      Assert.assertThat(ex.getMessage(), CoreMatchers.containsString("Could not 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,6 +18,8 @@
 
 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.cloud.tools.jib.frontend.MultipleClassesFoundException;
 import com.google.common.base.Preconditions;
 import java.io.IOException;
 import javax.annotation.Nullable;
@@ -57,10 +59,21 @@ 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.info(
+            "Could not find main class specified in maven-jar-plugin; attempting to infer main "
+                + "class.");
+        try {
+          mainClass = MainClassFinder.findMainClass(project.getBuild().getOutputDirectory());
+        } catch (MultipleClassesFoundException | IOException ex) {
+          throw new MojoExecutionException(
+              HelpfulSuggestionsProvider.get("Failed to get main class: " + ex.getMessage())
+                  .suggest("add a `mainClass` configuration to jib-maven-plugin"));
+        }
+        if (mainClass == null) {
+          throw new MojoExecutionException(
+              HelpfulSuggestionsProvider.get("Could not infer main class")
+                  .suggest("add a `mainClass` configuration to jib-maven-plugin"));
+        }
       }
     }
     Preconditions.checkNotNull(mainClass);