Soy Jbcsrc: Have our in memory classloaders delegate to the classloader that loaded them rather than the system classloader and apply the same protection domain

For most servers the system classloader is sufficient, but on app-engine things are different (the application and thus the compiler are loaded in a sub classloader), so in order to make sure that the compiled classes can access all the runtime libraries they need to delegate to the correct parent loader.
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=105452900

Author: lukesandberg

java/src/com/google/template/soy/jbcsrc/AbstractMemoryClassLoader.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * 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.template.soy.jbcsrc;
+
+import com.google.common.base.Throwables;
+
+import java.net.URL;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.security.ProtectionDomain;
+
+import javax.annotation.Nullable;
+
+/**
+ * Base class to share code between our custom memory based classloader implementations.
+ */
+abstract class AbstractMemoryClassLoader extends ClassLoader {
+  private static final ProtectionDomain DEFAULT_PROTECTION_DOMAIN;
+
+  static {
+    ClassLoader.registerAsParallelCapable();
+
+    DEFAULT_PROTECTION_DOMAIN =
+        AccessController.doPrivileged(
+            new PrivilegedAction<ProtectionDomain>() {
+              @Override
+              public ProtectionDomain run() {
+                return MemoryClassLoader.class.getProtectionDomain();
+              }
+            });
+  }
+
+  AbstractMemoryClassLoader() {
+    // We want our loaded classes to be a child classloader of ours to make sure they have access
+    // to the same classes that we do.
+    super(AbstractMemoryClassLoader.class.getClassLoader());
+  }
+
+  /** Returns a data object for a class with the given name or {@code null} if it doesn't exist. */
+  @Nullable
+  abstract ClassData getClassData(String name);
+
+  @Override
+  protected final Class<?> findClass(String name) throws ClassNotFoundException {
+    ClassData classDef = getClassData(name);
+    if (classDef == null) {
+      throw new ClassNotFoundException(name);
+    }
+    try {
+      return super.defineClass(
+          name, classDef.data(), 0, classDef.data().length, DEFAULT_PROTECTION_DOMAIN);
+    } catch (Throwable t) {
+      // Attach additional information in a suppressed exception to make debugging easier.
+      t.addSuppressed(new RuntimeException("Failed to load generated class:\n" + classDef));
+      Throwables.propagateIfInstanceOf(t, ClassNotFoundException.class);
+      throw Throwables.propagate(t);
+    }
+  }
+
+  @Override
+  protected final URL findResource(final String name) {
+    if (!name.endsWith(".class")) {
+      return null;
+    }
+    String className = name.substring(0, name.length() - ".class".length()).replace('/', '.');
+    ClassData classDef = getClassData(className);
+    if (classDef == null) {
+      return null;
+    }
+    return classDef.asUrl();
+  }
+}
+

java/src/com/google/template/soy/jbcsrc/BytecodeCompiler.java

@@ -26,6 +26,8 @@
 import com.google.template.soy.soytree.TemplateNode;
 import com.google.template.soy.soytree.TemplateRegistry;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -69,10 +71,9 @@ public static Optional<CompiledTemplates> compile(
     if (reporter.errorsSince(checkpoint)) {
       return Optional.absent();
     }
-    CompiledTemplates templates = 
+    CompiledTemplates templates =
         new CompiledTemplates(
-            compilerRegistry.getTemplateNames(),
-            results.loader());
+            compilerRegistry.getTemplateNames(), new MemoryClassLoader(results.classes()));
     logger.log(
         Level.INFO,
         "Compilation took {0}\n"
@@ -83,8 +84,8 @@ public static Optional<CompiledTemplates> compile(
             + "  detachStates: {5}",
         new Object[] {
           stopwatch.toString(),
-          results.numTemplates(),
-          results.numClasses(),
+          registry.getAllTemplates().size(),
+          results.classes().size(),
           results.numBytes(),
           results.numFields(),
           results.numDetachStates()
@@ -107,11 +108,7 @@ private static void checkForUnsupportedFeatures(TemplateRegistry registry,
 
   @AutoValue
   abstract static class CompilationResult {
-    abstract MemoryClassLoader loader();
-
-    abstract int numTemplates();
-
-    abstract int numClasses();
+    abstract List<ClassData> classes();
 
     abstract int numBytes();
 
@@ -128,17 +125,14 @@ private static CompilationResult compileTemplates(
       TemplateRegistry registry,
       CompiledTemplateRegistry compilerRegistry,
       ErrorReporter errorReporter) {
-    int numTemplates = 0;
-    int numClasses = 0;
+    List<ClassData> classes = new ArrayList<>();
     int numBytes = 0;
     int numFields = 0;
     int numDetachStates = 0;
-    MemoryClassLoader.Builder builder = new MemoryClassLoader.Builder();
     // We generate all the classes and then start loading them.  This 2 phase process ensures that
     // we don't have to worry about ordering (where a class we have generated references a class we
     // haven't generated yet), because none of the classes are loadable until they all are.
     for (TemplateNode template : registry.getAllTemplates()) {
-      numTemplates++;
       String name = template.getTemplateName();
       logger.log(Level.FINE, "Compiling template: {0}", name);
       try {
@@ -153,14 +147,13 @@ private static CompilationResult compileTemplates(
                 new Object[] {clazz.type().className(), clazz.data().length,
                     clazz.numberOfFields(), clazz.numberOfDetachStates()});
           }
-          numClasses++;
           numBytes += clazz.data().length;
           numFields += clazz.numberOfFields();
           numDetachStates += clazz.numberOfDetachStates();
           if (Flags.DEBUG) {
             clazz.checkClass();
           }
-          builder.add(clazz);
+          classes.add(clazz);
         }
       // Report unexpected errors and keep going to try to collect more.
       } catch (UnexpectedCompilerFailureException e) {
@@ -179,7 +172,7 @@ private static CompilationResult compileTemplates(
       }
     }
     return new AutoValue_BytecodeCompiler_CompilationResult(
-        builder.build(), numTemplates, numClasses, numBytes, numFields, numDetachStates);
+        classes, numBytes, numFields, numDetachStates);
   }
 
   private BytecodeCompiler() {}

java/src/com/google/template/soy/jbcsrc/CompilingClassLoader.java

@@ -16,17 +16,14 @@
 
 package com.google.template.soy.jbcsrc;
 
-import com.google.common.base.Throwables;
-
-import java.net.URL;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
 /**
  * A classloader that can compile templates on demand.
  */
-final class CompilingClassLoader extends ClassLoader {
+final class CompilingClassLoader extends AbstractMemoryClassLoader {
   static {
     // See http://docs.oracle.com/javase/7/docs/technotes/guides/lang/cl-mt.html
     ClassLoader.registerAsParallelCapable();
@@ -40,48 +37,18 @@ final class CompilingClassLoader extends ClassLoader {
   private final CompiledTemplateRegistry registry;
 
   CompilingClassLoader(CompiledTemplateRegistry registry) {
-    super(ClassLoader.getSystemClassLoader());
     this.registry = registry;
   }
-
-  @Override protected Class<?> findClass(String name) throws ClassNotFoundException {
+  
+  @Override
+  ClassData getClassData(String name) {
     ClassData classDef = classesByName.get(name);
-    if (classDef == null) {
-      // We haven't already compiled it (and haven't already loaded it) so try to find the matching
-      // template.
-      classDef = compile(name);
-      if (classDef == null) {
-        throw new ClassNotFoundException(name);
-      }
+    if (classDef != null) {
+      return classDef;
     }
-    try {
-      return super.defineClass(name, classDef.data(), 0, classDef.data().length);
-    } catch (Throwable t) {
-      // Attach additional information in a suppressed exception to make debugging easier.
-      t.addSuppressed(new RuntimeException("Failed to load generated class:\n" + classDef));
-      Throwables.propagateIfInstanceOf(t, ClassNotFoundException.class);
-      throw Throwables.propagate(t);
-    }
-  }
-
-  @Override protected URL findResource(final String name) {
-    if (!name.endsWith(".class")) {
-      return null;
-    }
-    String className = name.substring(0, name.length() - ".class".length()).replace('/', '.');
-    ClassData classDef = classesByName.get(className);
-    if (classDef == null) {
-      // We haven't already compiled it (and haven't already loaded it) so try to find the matching
-      // template.
-      classDef = compile(name);
-      if (classDef == null) {
-        return null;
-      }
-    }
-    return classDef.asUrl();
-  }
+    // We haven't already compiled it (and haven't already loaded it) so try to find the matching
+    // template.
 
-  private ClassData compile(String name) {
     // For each template we compile there are only two 'public' classes that could be loaded prior
     // to compiling the template. The CompiledTemplate.Factory class and the CompiledTemplate itself
     boolean isFactory = name.endsWith("$" + StandardNames.FACTORY_CLASS);

java/src/com/google/template/soy/jbcsrc/MemoryClassLoader.java

@@ -16,47 +16,19 @@
 
 package com.google.template.soy.jbcsrc;
 
-import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableMap;
 
-import java.net.URL;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
 /**
- * A {@link ClassLoader} that can load classes from a configured set of {@code byte[]}s. 
+ * A {@link ClassLoader} that can load classes from a configured set of {@code byte[]}s.
  */
-final class MemoryClassLoader extends ClassLoader {
+final class MemoryClassLoader extends AbstractMemoryClassLoader {
   static {
     // Since we only override findClass(), we can call this method to get fine grained locking
     // support with no additional work. Our superclass will lock all calls to findClass with a per
     // class to load lock, so we will never see concurrent loads of a single class. 
     // See http://docs.oracle.com/javase/7/docs/technotes/guides/lang/cl-mt.html
     ClassLoader.registerAsParallelCapable();
   }
-  
-  static final class Builder {
-    private final Map<String, ClassData> generatedClasses = new LinkedHashMap<>();
-
-    Builder addAll(Iterable<ClassData> classes) {
-      for (ClassData item : classes) {
-        add(item);
-      }
-      return this;
-    }
-
-    Builder add(ClassData classData) {
-      ClassData prev = generatedClasses.put(classData.type().className(), classData);
-      if (prev != null) {
-        throw new IllegalStateException("multiple classes generated named: " + classData.type());
-      }
-      return this;
-    }
-
-    MemoryClassLoader build() {
-      return new MemoryClassLoader(generatedClasses);
-    }
-  }
 
   /**
    * We store all the classes in this map and rely on normal classloading resolution.
@@ -65,36 +37,16 @@ MemoryClassLoader build() {
    */
   private final ImmutableMap<String, ClassData> classesByName;
 
-  private MemoryClassLoader(Map<String, ClassData> generatedClasses) {
-    super(ClassLoader.getSystemClassLoader());
-    this.classesByName = ImmutableMap.copyOf(generatedClasses);
-  }
-
-  @Override protected Class<?> findClass(String name) throws ClassNotFoundException {
-    // replace so we don't hang onto the bytes for no reason
-    ClassData classDef = classesByName.get(name);
-    if (classDef == null) {
-      throw new ClassNotFoundException(name);
-    }
-    try {
-      return super.defineClass(name, classDef.data(), 0, classDef.data().length);
-    } catch (Throwable t) {
-      // Attach additional information in a suppressed exception to make debugging easier.
-      t.addSuppressed(new RuntimeException("Failed to load generated class:\n" + classDef));
-      Throwables.propagateIfInstanceOf(t, ClassNotFoundException.class);
-      throw Throwables.propagate(t);
+  MemoryClassLoader(Iterable<ClassData> classes) {
+    ImmutableMap.Builder<String, ClassData> builder = ImmutableMap.builder();
+    for (ClassData classData : classes) {
+      builder.put(classData.type().className(), classData);
     }
+    this.classesByName = builder.build();
   }
-  
-  @Override protected URL findResource(final String name) {
-    if (!name.endsWith(".class")) {
-      return null;
-    }
-    String className = name.substring(0, name.length() - ".class".length()).replace('/', '.');
-    ClassData classDef = classesByName.get(className);
-    if (classDef == null) {
-      return null;
-    }
-    return classDef.asUrl();
+
+  @Override
+  ClassData getClassData(String name) {
+    return classesByName.get(name);
   }
 }

java/tests/com/google/template/soy/jbcsrc/ExpressionTester.java

@@ -20,6 +20,7 @@
 
 import com.google.common.base.Joiner;
 import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableList;
 import com.google.common.truth.FailureStrategy;
 import com.google.common.truth.Subject;
 import com.google.common.truth.SubjectFactory;
@@ -232,7 +233,7 @@ static <T> T createInvoker(Class<T> clazz, Expression expr) {
   }
 
   private static <T> T load(Class<T> clazz, ClassData data) {
-    MemoryClassLoader loader = new MemoryClassLoader.Builder().add(data).build();
+    MemoryClassLoader loader = new MemoryClassLoader(ImmutableList.of(data));
     Class<?> generatedClass;
     try {
       generatedClass = loader.loadClass(data.type().className());

java/tests/com/google/template/soy/jbcsrc/TemplateTester.java

@@ -297,9 +297,9 @@ private void compile() {
             compilerRegistry,
             compilerRegistry.getTemplateInfoByTemplateName(templateName)).compile();
         checkClasses(classData);
-        factory = new CompiledTemplates(
-            compilerRegistry.getTemplateNames(), 
-            new MemoryClassLoader.Builder().addAll(classData).build())
+        factory =
+            new CompiledTemplates(
+                    compilerRegistry.getTemplateNames(), new MemoryClassLoader(classData))
                 .getTemplateFactory(templateName);
       }
     }