Import of Cloud Functions JVM from Git-on-Borg.

  - b56a91a933b6f438b06ca65fe70b31105fa15fbc Hide the runtime from functions loaded via -jar. by Éamonn McManus <[email protected]>

PiperOrigin-RevId: 288496834

Author: eamonnmcmanus

invoker-core/core/pom.xml

@@ -19,7 +19,6 @@
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <maven-compiler-plugin.version>3.8.0</maven-compiler-plugin.version>
     <junit.jupiter.version>5.3.2</junit.jupiter.version>
   </properties>
 
@@ -84,6 +83,13 @@
     </dependency>
 
     <!-- Test dependencies -->
+    <dependency>
+      <groupId>com.google.cloud.functions.invoker</groupId>
+      <artifactId>java-function-invoker-core-functionjar</artifactId>
+      <version>1.0.0-alpha-1</version>
+      <type>test-jar</type>
+      <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
@@ -124,18 +130,8 @@
 
   <build>
     <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>${maven-compiler-plugin.version}</version>
-        <configuration>
-          <source>1.8</source>
-          <target>1.8</target>
-        </configuration>
-      </plugin>
       <!-- Rename dependencies used by invoker-core so that they don't interfere with user dependencies -->
       <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-shade-plugin</artifactId>
         <version>3.2.1</version>
         <executions>

invoker-core/core/src/main/java/com/google/cloud/functions/invoker/NewBackgroundFunctionExecutor.java

@@ -38,10 +38,11 @@ private NewBackgroundFunctionExecutor(RawBackgroundFunction function) {
    *    either the class does not implement {@link RawBackgroundFunction} or we are unable to
    *    construct an instance using its no-arg constructor.
    */
-  public static Optional<NewBackgroundFunctionExecutor> forTarget(String target) {
+  public static Optional<NewBackgroundFunctionExecutor> forTarget(
+      String target, ClassLoader loader) {
     Class<?> c;
     try {
-      c = Class.forName(target);
+      c = loader.loadClass(target);
     } catch (ClassNotFoundException e) {
       return Optional.empty();
     }

invoker-core/core/src/main/java/com/google/cloud/functions/invoker/NewHttpFunctionExecutor.java

@@ -31,11 +31,11 @@ private NewHttpFunctionExecutor(HttpFunction function) {
    *    either the class does not implement {@link HttpFunction} or we are unable to construct an
    *    instance using its no-arg constructor.
    */
-  public static Optional<NewHttpFunctionExecutor> forTarget(String target) {
+  public static Optional<NewHttpFunctionExecutor> forTarget(String target, ClassLoader loader) {
     Class<?> c;
     while (true) {
       try {
-        c = Class.forName(target);
+        c = loader.loadClass(target);
         break;
       } catch (ClassNotFoundException e) {
         // This might be a nested class like com.example.Foo.Bar. That will actually appear as

invoker-core/core/src/main/java/com/google/cloud/functions/invoker/runner/Invoker.java

@@ -11,6 +11,7 @@
 import com.google.cloud.functions.invoker.NewHttpFunctionExecutor;
 import java.io.File;
 import java.io.IOException;
+import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Arrays;
@@ -139,24 +140,23 @@ public void startServer() throws Exception {
             : Optional.empty();
     if (functionJarFile.isPresent() && !functionJarFile.get().exists()) {
       throw new IllegalArgumentException(
-          "functionJarPath points to an non-existing file: "
+          "functionJarPath points to an non-existent file: "
               + functionJarFile.get().getAbsolutePath());
     }
 
+    ClassLoader runtimeLoader = getClass().getClassLoader();
     ClassLoader classLoader;
     if (functionJarFile.isPresent()) {
-      classLoader =
-          new URLClassLoader(
-              new URL[]{functionJarFile.get().toURI().toURL()},
-              Thread.currentThread().getContextClassLoader());
+      ClassLoader parent = new OnlyApiClassLoader(runtimeLoader);
+      classLoader = new URLClassLoader(new URL[]{functionJarFile.get().toURI().toURL()}, parent);
     } else {
-      classLoader = Thread.currentThread().getContextClassLoader();
+      classLoader = runtimeLoader;
     }
 
     if ("http".equals(functionSignatureType)) {
       HttpServlet servlet;
       Optional<NewHttpFunctionExecutor> newExecutor =
-          NewHttpFunctionExecutor.forTarget(functionTarget);
+          NewHttpFunctionExecutor.forTarget(functionTarget, classLoader);
       if (newExecutor.isPresent()) {
         servlet = newExecutor.get();
       } else {
@@ -169,7 +169,7 @@ public void startServer() throws Exception {
     } else if ("event".equals(functionSignatureType)) {
       HttpServlet servlet;
       Optional<NewBackgroundFunctionExecutor> newExecutor =
-          NewBackgroundFunctionExecutor.forTarget(functionTarget);
+          NewBackgroundFunctionExecutor.forTarget(functionTarget, classLoader);
       if (newExecutor.isPresent()) {
         servlet = newExecutor.get();
       } else {
@@ -196,4 +196,45 @@ private void logServerInfo() {
       logger.log(Level.INFO, "URL: http://localhost:{0,number,#}/", port);
     }
   }
+
+  /**
+   * A loader that only loads GCF API classes. Those are classes whose package is exactly
+   * {@code com.google.cloud.functions}. The package can't be a subpackage, such as
+   * {@code com.google.cloud.functions.invoker}.
+   *
+   * <p>This loader allows us to load the classes from a user function, without making the
+   * runtime classes visible to them.  We will make this loader the parent of the
+   * {@link URLClassLoader} that loads the user code in order to filter out those runtime classes.
+   *
+   * <p>The reason we do need to share the API classes between the runtime and the user function is
+   * so that the runtime can instantiate the function class and cast it to
+   * {@link com.google.cloud.functions.HttpFunction} or whatever.
+   */
+  private static class OnlyApiClassLoader extends ClassLoader {
+    private final ClassLoader runtimeClassLoader;
+
+    OnlyApiClassLoader(ClassLoader runtimeClassLoader) {
+      super(getSystemOrBootstrapClassLoader());
+      this.runtimeClassLoader = runtimeClassLoader;
+    }
+
+    @Override
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+      String prefix = "com.google.cloud.functions.";
+      if (name.startsWith(prefix) && Character.isUpperCase(name.charAt(prefix.length()))) {
+        return runtimeClassLoader.loadClass(name);
+      }
+      return super.findClass(name); // should throw ClassNotFoundException
+    }
+
+    private static ClassLoader getSystemOrBootstrapClassLoader() {
+      try {
+        // We're still building against the Java 8 API, so we have to use reflection for now.
+        Method getPlatformClassLoader = ClassLoader.class.getMethod("getPlatformClassLoader");
+        return (ClassLoader) getPlatformClassLoader.invoke(null);
+      } catch (ReflectiveOperationException e) {
+        return null;
+      }
+    }
+  }
 }

invoker-core/core/src/test/java/com/google/cloud/functions/invoker/IntegrationTest.java

@@ -2,11 +2,13 @@
 
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth.assertWithMessage;
+import static java.util.stream.Collectors.toList;
 
 import com.google.auto.value.AutoValue;
 import com.google.cloud.functions.invoker.runner.Invoker;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import com.google.common.io.Files;
+import com.google.common.collect.Iterables;
 import com.google.common.io.Resources;
 import com.google.gson.Gson;
 import com.google.gson.JsonObject;
@@ -19,10 +21,15 @@
 import java.net.ServerSocket;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
 import org.eclipse.jetty.client.HttpClient;
 import org.eclipse.jetty.client.api.ContentResponse;
 import org.eclipse.jetty.client.api.Request;
@@ -163,6 +170,53 @@ public void packageless() throws Exception {
         TestCase.builder().setExpectedResponseText("hello, world\n").build());
   }
 
+  /** Any runtime class that user code shouldn't be able to see. */
+  private static final Class<?> INTERNAL_CLASS = CloudFunction.class;
+
+  private String functionJarString() throws IOException {
+    Path functionJarTargetDir = Paths.get("../functionjar/target");
+    Pattern functionJarPattern = Pattern.compile("java-function-invoker-core-functionjar-.*\\.jar");
+    List<Path> functionJars = Files.list(functionJarTargetDir)
+        .map(path -> path.getFileName().toString())
+        .filter(s -> functionJarPattern.matcher(s).matches())
+        .map(s -> functionJarTargetDir.resolve(s))
+        .collect(toList());
+    assertWithMessage("Number of jars in %s matching %s", functionJarTargetDir, functionJarPattern)
+        .that(functionJars).hasSize(1);
+    return Iterables.getOnlyElement(functionJars).toString();
+  }
+
+  /**
+   * Tests that if we launch an HTTP function with {@code -jar}, then the function code cannot
+   * see the classes from the runtime. This is allows us to avoid conflicts between versions of
+   * libraries that we use in the runtime and different versions of the same libraries that the
+   * function might use.
+   */
+  @Test
+  public void jarOptionHttp() throws Exception {
+    testHttpFunction("com.example.functionjar.Foreground",
+        ImmutableList.of("-jar", functionJarString()),
+        TestCase.builder()
+            .setUrl("/?class=" + INTERNAL_CLASS.getName())
+            .setExpectedResponseText("OK")
+            .build());
+  }
+
+  /** Like {@link #jarOptionHttp} but for background functions. */
+  @Test
+  public void jarOptionBackground() throws Exception {
+    Gson gson = new Gson();
+    URL resourceUrl = getClass().getResource("/adder_gcf_ga_event.json");
+    assertThat(resourceUrl).isNotNull();
+    String originalJson = Resources.toString(resourceUrl, StandardCharsets.UTF_8);
+    JsonObject json = gson.fromJson(originalJson, JsonObject.class);
+    JsonObject jsonData = json.getAsJsonObject("data");
+    jsonData.addProperty("class", INTERNAL_CLASS.getName());
+    testBackgroundFunction("com.example.functionjar.Background",
+        ImmutableList.of("-jar", functionJarString()),
+        TestCase.builder().setRequestText(json.toString()).build());
+  }
+
   // In these tests, we test a number of different functions that express the same functionality
   // in different ways. Each function is invoked with a complete HTTP body that looks like a real
   // event. We start with a fixed body and insert into its JSON an extra property that tells the
@@ -180,23 +234,36 @@ private void backgroundTest(String functionTarget) throws Exception {
     jsonData.addProperty("targetFile", snoopFile.toString());
     testBackgroundFunction(functionTarget,
         TestCase.builder().setRequestText(json.toString()).build());
-    String snooped = Files.asCharSource(snoopFile, StandardCharsets.UTF_8).read();
+    String snooped = new String(Files.readAllBytes(snoopFile.toPath()), StandardCharsets.UTF_8);
     JsonObject snoopedJson = gson.fromJson(snooped, JsonObject.class);
     assertThat(snoopedJson).isEqualTo(json);
   }
 
   private void testHttpFunction(String target, TestCase... testCases) throws Exception {
-    testFunction(SignatureType.HTTP, target, testCases);
+    testHttpFunction(target, ImmutableList.of(), testCases);
+  }
+
+  private void testHttpFunction(
+      String target, ImmutableList<String> extraArgs, TestCase... testCases) throws Exception {
+    testFunction(SignatureType.HTTP, target, extraArgs, testCases);
   }
 
   private void testBackgroundFunction(String classAndMethod, TestCase... testCases)
       throws Exception {
-    testFunction(SignatureType.BACKGROUND, classAndMethod, testCases);
+    testBackgroundFunction(classAndMethod, ImmutableList.of(), testCases);
+  }
+  private void testBackgroundFunction(
+      String classAndMethod, ImmutableList<String> extraArgs, TestCase... testCases)
+      throws Exception {
+    testFunction(SignatureType.BACKGROUND, classAndMethod, extraArgs, testCases);
   }
 
   private void testFunction(
-      SignatureType signatureType, String target, TestCase... testCases) throws Exception {
-    Process server = startServer(signatureType, target);
+      SignatureType signatureType,
+      String target,
+      ImmutableList<String> extraArgs,
+      TestCase... testCases) throws Exception {
+    Process server = startServer(signatureType, target, extraArgs);
     try {
       HttpClient httpClient = new HttpClient();
       httpClient.start();
@@ -233,7 +300,8 @@ public String toString() {
     }
   }
 
-  private Process startServer(SignatureType signatureType, String target)
+  private Process startServer(
+      SignatureType signatureType, String target, ImmutableList<String> extraArgs)
       throws IOException, InterruptedException {
     File javaHome = new File(System.getProperty("java.home"));
     assertThat(javaHome.exists()).isTrue();
@@ -242,9 +310,10 @@ private Process startServer(SignatureType signatureType, String target)
     assertThat(javaCommand.exists()).isTrue();
     String myClassPath = System.getProperty("java.class.path");
     assertThat(myClassPath).isNotNull();
-    String[] command = {
-        javaCommand.toString(), "-classpath", myClassPath, Invoker.class.getName(),
-    };
+    ImmutableList<String> command = ImmutableList.<String>builder()
+        .add(javaCommand.toString(), "-classpath", myClassPath, Invoker.class.getName())
+        .addAll(extraArgs)
+        .build();
     ProcessBuilder processBuilder = new ProcessBuilder()
         .command(command)
         .redirectErrorStream(true);
@@ -256,7 +325,8 @@ private Process startServer(SignatureType signatureType, String target)
     Process serverProcess = processBuilder.start();
     CountDownLatch ready = new CountDownLatch(1);
     new Thread(() -> monitorOutput(serverProcess.getInputStream(), ready)).start();
-    ready.await(5, TimeUnit.SECONDS);
+    boolean serverReady = ready.await(5, TimeUnit.SECONDS);
+    assertWithMessage("Waiting for server to be ready").that(serverReady).isTrue();
     return serverProcess;
   }