Introduction of new API for metadata registration based on conditions.

Author: Mihailo Markovic

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/Feature.java

@@ -171,6 +171,14 @@ interface IsInConfigurationAccess extends FeatureAccess {
 */
 @Platforms(Platform.HOSTED_ONLY.class)
 interface AfterRegistrationAccess extends FeatureAccess {
+/**
+* Creates access for runtime registration. All registrations should happen in
+* {@link Feature#afterRegistration}
+*
+*/
+ReflectionDynamicAccess createReflectionDynamicAccess();
+
+ResourceDynamicAccess createResourceDynamicAccess();
 }
 
 /**

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/ReflectionDynamicAccess.java

@@ -0,0 +1,61 @@
+package org.graalvm.nativeimage.hosted;
+
+import java.lang.reflect.Executable;
+import java.lang.reflect.Field;
+
+/**
+* This interface is used to register classes, methods, fields for reflection, serialization, and
+* JNI access at runtime.
+*
+* {@link ReflectionDynamicAccess} is based on {@link RegistrationCondition}. Registration of any
+* class and its members for dynamic access will succeed only if condition is met.
+*
+* {@link ReflectionDynamicAccess} should only be used at {@link Feature#afterRegistration}.
+*/
+public interface ReflectionDynamicAccess {
+
+/**
+* Makes the provided classes available for reflection at runtime, and all of their accessible
+* members available for reflection queries at run time if {@code condition} is satisfied. A
+* call to {@link Class#forName} for the names of the classes will return the classes at run
+* time.
+*
+* @param condition needs to be satisfied for inclusion of types for reflection at runtime
+*/
+void register(RegistrationCondition condition, Class<?>... classes);
+
+/**
+* Makes the provided class available for reflection at runtime if {@code condition} is
+* satisfied. A call to {@link Class#forName} for the name of the class will return the class
+* (if it exists) or a {@link ClassNotFoundException} at run time.
+*/
+void registerClassLookup(RegistrationCondition condition, String className);
+
+/**
+* Makes the provided methods available for reflection at runtime if {@code condition} is
+* satisfied. The methods will be returned by {@link Class#getMethod},
+* {@link Class#getDeclaredMethod(String, Class[])}, and all the other methods on {@link Class}
+* that return a single method. Methods can be invoked reflectively.
+*/
+void register(RegistrationCondition condition, Executable... methods);
+
+/**
+* Makes the provided fields available for reflection at runtime if {@code condition} is
+* satisfied. The fields will be returned by {@link Class#getField},
+* {@link Class#getDeclaredField(String)}, and all the other methods on {@link Class} that
+* return a single field. The fields can be accessed reflectively.
+*/
+void register(RegistrationCondition condition, Field... fields);
+
+/**
+* Makes the provided classes available for both serialization and reflection at runtime if
+* {@code condition} is satisfied.
+*/
+void registerForSerialization(RegistrationCondition condition, Class<?>... classes);
+
+/**
+* Makes the provided classes available for both JNI access and reflection at runtime if
+* {@code condition} is satisfied.
+*/
+void registerForJNIAccess(RegistrationCondition condition, Class<?>... classes);
+}

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/ResourceDynamicAccess.java

@@ -0,0 +1,38 @@
+package org.graalvm.nativeimage.hosted;
+
+/**
+* This interface is used to register Java resources and ResourceBundles that should be accessible
+* at runtime.
+*
+* {@link ResourceDynamicAccess} is based on {@link RegistrationCondition}. Registration of any
+* resource for dynamic access will succeed only if condition is met.
+*
+* {@link ResourceDynamicAccess} should only be used at {@link Feature#afterRegistration}.
+*/
+public interface ResourceDynamicAccess {
+
+/**
+* If {@code pattern} contains any wildcard patterns, such as star(*) or globstar(**), pattern
+* is treated as glob pattern from {@code module} and it will be registered if {@code condition}
+* is satisfied. All resources that match the glob are available at runtime. Otherwise, pattern
+* represents Java resource from {@code module} that will be available at run time if
+* {@code condition} is satisfied. If the given {@code module} is omitted or null, Java resource
+* is looked up on the classpath instead.
+*/
+void register(RegistrationCondition condition, Module module, String pattern);
+
+default void register(RegistrationCondition condition, String pattern) {
+register(condition, null, pattern);
+}
+
+/**
+* Makes Java ResourceBundle that is specified by a {@code bundleName} from module
+* {@code module} available at run time if {@code condition} is satisfied. If the given
+* {@code module} is omitted or null, the ResourceBundle is looked up on the classpath instead.
+*/
+void registerResourceBundle(RegistrationCondition condition, Module module, String bundleName);
+
+default void registerResourceBundle(RegistrationCondition condition, String bundleName) {
+registerResourceBundle(condition, null, bundleName);
+}
+}

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/RuntimeReflectionSupport.java

@@ -54,6 +54,10 @@ public interface RuntimeReflectionSupport extends ReflectionRegistry {
 
 void registerAllDeclaredMethodsQuery(RegistrationCondition condition, boolean queriedOnly, Class<?> clazz);
 
+void registerAllFieldsQuery(RegistrationCondition condition, boolean queriedOnly, Class<?> clazz);
+
+void registerAllDeclaredFieldsQuery(RegistrationCondition condition, boolean queriedOnly, Class<?> clazz);
+
 void registerAllConstructorsQuery(RegistrationCondition condition, boolean queriedOnly, Class<?> clazz);
 
 void registerAllDeclaredConstructorsQuery(RegistrationCondition condition, boolean queriedOnly, Class<?> clazz);

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/RuntimeSerializationSupport.java

@@ -56,6 +56,10 @@ static RuntimeSerializationSupport<RegistrationCondition> singleton() {
 
 void registerIncludingAssociatedClasses(C condition, Class<?> clazz);
 
+default void register(C condition, Class<?>... classes) {
+Arrays.stream(classes).forEach(clazz -> register(condition, clazz));
+}
+
 void register(C condition, Class<?> clazz);
 
 void register(C condition, String clazz);

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ConditionalConfigurationRegistry.java

@@ -69,9 +69,7 @@ protected void registerConditionalConfiguration(RegistrationCondition condition,
 } else {
 beforeAnalysisAccess.registerReachabilityHandler(access -> consumer.accept(runtimeCondition), ((TypeReachabilityCondition) condition).getKey());
 }
-
 }
-
 }
 
 public void setAnalysisAccess(Feature.BeforeAnalysisAccess beforeAnalysisAccess) {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FeatureImpl.java

@@ -51,6 +51,8 @@
 import org.graalvm.nativeimage.hosted.Feature.DuringAnalysisAccess;
 import org.graalvm.nativeimage.hosted.FieldValueTransformer;
 import org.graalvm.nativeimage.hosted.RegistrationCondition;
+import org.graalvm.nativeimage.hosted.ReflectionDynamicAccess;
+import org.graalvm.nativeimage.hosted.ResourceDynamicAccess;
 import org.graalvm.nativeimage.hosted.RuntimeReflection;
 
 import com.oracle.graal.pointsto.BigBang;
@@ -192,6 +194,16 @@ public void setMainEntryPoint(Pair<Method, CEntryPointData> mainEntryPoint) {
 public Pair<Method, CEntryPointData> getMainEntryPoint() {
 return mainEntryPoint;
 }
+
+@Override
+public ReflectionDynamicAccess createReflectionDynamicAccess() {
+return new ReflectionDynamicAccessImpl();
+}
+
+@Override
+public ResourceDynamicAccess createResourceDynamicAccess() {
+return new ResourceDynamicAccessImpl();
+}
 }
 
 abstract static class AnalysisAccessBase extends FeatureAccessImpl {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/InternalReflectionDynamicAccessImpl.java

@@ -0,0 +1,66 @@
+package com.oracle.svm.hosted;
+
+import java.lang.reflect.Executable;
+import java.lang.reflect.Field;
+
+import org.graalvm.nativeimage.ImageSingletons;
+import org.graalvm.nativeimage.hosted.ReflectionDynamicAccess;
+import org.graalvm.nativeimage.hosted.RegistrationCondition;
+import org.graalvm.nativeimage.impl.RuntimeJNIAccessSupport;
+import org.graalvm.nativeimage.impl.RuntimeReflectionSupport;
+import org.graalvm.nativeimage.impl.RuntimeSerializationSupport;
+
+public class InternalReflectionDynamicAccessImpl implements ReflectionDynamicAccess {
+
+private static RuntimeReflectionSupport rrsInstance;
+
+InternalReflectionDynamicAccessImpl() {
+rrsInstance = ImageSingletons.lookup(RuntimeReflectionSupport.class);
+}
+
+@Override
+public void register(RegistrationCondition condition, Class<?>... classes) {
+rrsInstance.register(condition, classes);
+for (Class<?> clazz : classes) {
+rrsInstance.registerAllClassesQuery(condition, clazz);
+rrsInstance.registerAllDeclaredClassesQuery(condition, clazz);
+rrsInstance.registerAllDeclaredMethodsQuery(condition, true, clazz);
+rrsInstance.registerAllMethodsQuery(condition, true, clazz);
+rrsInstance.registerAllDeclaredConstructorsQuery(condition, true, clazz);
+rrsInstance.registerAllConstructorsQuery(condition, true, clazz);
+rrsInstance.registerAllFieldsQuery(condition, true, clazz);
+rrsInstance.registerAllDeclaredFieldsQuery(condition, true, clazz);
+rrsInstance.registerAllNestMembersQuery(condition, clazz);
+rrsInstance.registerAllPermittedSubclassesQuery(condition, clazz);
+rrsInstance.registerAllRecordComponentsQuery(condition, clazz);
+rrsInstance.registerAllSignersQuery(condition, clazz);
+}
+}
+
+@Override
+public void registerClassLookup(RegistrationCondition condition, String className) {
+rrsInstance.registerClassLookup(condition, className);
+}
+
+@Override
+public void register(RegistrationCondition condition, Executable... methods) {
+rrsInstance.register(condition, false, methods);
+}
+
+@Override
+public void register(RegistrationCondition condition, Field... fields) {
+rrsInstance.register(condition, false, fields);
+}
+
+@Override
+public void registerForSerialization(RegistrationCondition condition, Class<?>... classes) {
+register(condition, classes);
+RuntimeSerializationSupport.singleton().register(condition, classes);
+}
+
+@Override
+public void registerForJNIAccess(RegistrationCondition condition, Class<?>... classes) {
+register(condition, classes);
+ImageSingletons.lookup(RuntimeJNIAccessSupport.class).register(condition, classes);
+}
+}

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/InternalResourceDynamicAccessImpl.java

@@ -0,0 +1,37 @@
+package com.oracle.svm.hosted;
+
+import java.util.Objects;
+
+import org.graalvm.nativeimage.hosted.RegistrationCondition;
+import org.graalvm.nativeimage.hosted.ResourceDynamicAccess;
+import org.graalvm.nativeimage.impl.RuntimeResourceSupport;
+
+public class InternalResourceDynamicAccessImpl implements ResourceDynamicAccess {
+
+private static RuntimeResourceSupport<RegistrationCondition> rrsInstance;
+
+InternalResourceDynamicAccessImpl() {
+rrsInstance = RuntimeResourceSupport.singleton();
+}
+
+@Override
+public void register(RegistrationCondition condition, Module module, String pattern) {
+if (pattern.replace("\\*", "").contains("*")) {
+String moduleName = module == null ? null : module.getName();
+rrsInstance.addGlob(condition, moduleName, pattern, "Registered from API");
+} else {
+rrsInstance.addResource(condition, module, pattern.replace("\\*", "*"), "Registered from API");
+}
+}
+
+@Override
+public void registerResourceBundle(RegistrationCondition condition, Module module, String bundleName) {
+rrsInstance.addResourceBundles(condition, resolveModuleName(module, bundleName));
+}
+
+private static String resolveModuleName(Module module, String str) {
+Objects.requireNonNull(str);
+boolean isNamed = module == null ? false : module.isNamed();
+return ((isNamed) ? module.getName() : "ALL-UNNAMED") + ":" + str;
+}
+}

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGenerator.java

@@ -978,6 +978,8 @@ protected void setupNativeImage(String imageName, OptionValues options, Map<Meth
 
 AfterRegistrationAccessImpl access = new AfterRegistrationAccessImpl(featureHandler, loader, originalMetaAccess, mainEntryPoint, debug);
 featureHandler.forEachFeature(feature -> feature.afterRegistration(access));
+ReflectionDynamicAccessImpl.setAfterRegistrationFinished();
+ResourceDynamicAccessImpl.setAfterRegistrationFinished();
 setDefaultLibCIfMissing();
 if (!Pair.<Method, CEntryPointData> empty().equals(access.getMainEntryPoint())) {
 setAndVerifyMainEntryPoint(access, entryPoints);

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ReflectionDynamicAccessImpl.java

@@ -0,0 +1,73 @@
+package com.oracle.svm.hosted;
+
+import java.lang.reflect.Executable;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+
+import org.graalvm.nativeimage.hosted.Feature;
+import org.graalvm.nativeimage.hosted.ReflectionDynamicAccess;
+import org.graalvm.nativeimage.hosted.RegistrationCondition;
+
+import com.oracle.svm.core.util.UserError;
+
+/**
+* Instance of this class is used to register classes, methods, and fields for reflection,
+* serialization and JNI access at runtime. It can only be created at
+* {@link Feature#afterRegistration} via {@link Feature.AfterRegistrationAccess}.
+*/
+public final class ReflectionDynamicAccessImpl implements ReflectionDynamicAccess {
+
+private static boolean afterRegistrationFinished;
+private static InternalReflectionDynamicAccessImpl rdaInstance;
+
+public ReflectionDynamicAccessImpl() {
+rdaInstance = new InternalReflectionDynamicAccessImpl();
+afterRegistrationFinished = false;
+}
+
+public static void setAfterRegistrationFinished() {
+afterRegistrationFinished = true;
+}
+
+@Override
+public void register(RegistrationCondition condition, Class<?>... classes) {
+UserError.guarantee(!afterRegistrationFinished, "There shouldn't be a registration for runtime access after afterRegistration period. You tried to register: %s",
+Arrays.toString(classes));
+rdaInstance.register(condition, classes);
+}
+
+@Override
+public void registerClassLookup(RegistrationCondition condition, String className) {
+UserError.guarantee(!afterRegistrationFinished, "There shouldn't be a registration for runtime access after afterRegistration period. You tried to register: %s",
+className);
+rdaInstance.registerClassLookup(condition, className);
+}
+
+@Override
+public void register(RegistrationCondition condition, Executable... methods) {
+UserError.guarantee(!afterRegistrationFinished, "There shouldn't be a registration for runtime access after afterRegistration period. You tried to register: %s",
+Arrays.toString(methods));
+rdaInstance.register(condition, methods);
+}
+
+@Override
+public void register(RegistrationCondition condition, Field... fields) {
+UserError.guarantee(!afterRegistrationFinished, "There shouldn't be a registration for runtime access after afterRegistration period. You tried to register: %s",
+Arrays.toString(fields));
+rdaInstance.register(condition, fields);
+}
+
+@Override
+public void registerForSerialization(RegistrationCondition condition, Class<?>... classes) {
+UserError.guarantee(!afterRegistrationFinished, "There shouldn't be a registration for runtime access after afterRegistration period. You tried to register: %s",
+Arrays.toString(classes));
+rdaInstance.registerForSerialization(condition, classes);
+}
+
+@Override
+public void registerForJNIAccess(RegistrationCondition condition, Class<?>... classes) {
+UserError.guarantee(!afterRegistrationFinished, "There shouldn't be a registration for runtime access after afterRegistration period. You tried to register: %s",
+Arrays.toString(classes));
+rdaInstance.registerForJNIAccess(condition, classes);
+}
+}