Add an experimental minimal distribution to be published

- For usage with optimized for size Java and GraalVM native compilation images
- Maven groupId is set to org.apache.tomcat.experimental to classify it during evaluation of viability
- Does not ship as part of the standard Apache Tomcat library and sources

Author: fhanik

build.xml

@@ -60,6 +60,10 @@ public static boolean setProperty(Object o, String name, String value,
             log.debug("IntrospectionUtils: setProperty(" +
                     o.getClass() + " " + name + "=" + value + ")");
 
+        if (actualMethod == null && XReflectionIntrospectionUtils.isEnabled()) {
+            return XReflectionIntrospectionUtils.setPropertyInternal(o, name, value, invokeSetProperty);
+        }
+
         String setter = "set" + capitalize(name);
 
         try {
@@ -222,6 +226,9 @@ else if (c == '\r')
     }
 
     public static Object getProperty(Object o, String name) {
+        if (XReflectionIntrospectionUtils.isEnabled()) {
+            return XReflectionIntrospectionUtils.getPropertyInternal(o, name);
+        }
         String getter = "get" + capitalize(name);
         String isGetter = "is" + capitalize(name);
 

java/org/apache/tomcat/util/IntrospectionUtils.java

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.tomcat.util;
+
+final class XReflectionIntrospectionUtils {
+
+    static boolean isEnabled() {
+        return false;
+    }
+
+    static Object getPropertyInternal(Object o, String name) {
+        throw new UnsupportedOperationException();
+    }
+
+    static boolean setPropertyInternal(Object o, String name, String value, boolean invokeSetProperty) {
+        throw new UnsupportedOperationException();
+    }
+
+}

java/org/apache/tomcat/util/XReflectionIntrospectionUtils.java

@@ -51,11 +51,12 @@ native-image \
 --initialize-at-run-time=org.apache,jakarta.servlet \
 -H:+TraceClassInitialization \
 -H:+PrintClassInitialization \
+-H:+PrintAnalysisCallTree \
 -H:Name=tc-graal-image \
 -H:+ReportExceptionStackTraces \
 --allow-incomplete-classpath \
 --no-fallback \
--cp ../embed/tomcat-embed-core.jar:../embed/tomcat-embed-websocket.jar:../embed/tomcat-embed-el.jar:tomcat-embedded-sample.jar:../embed/annotations-api.jar \
+-cp ../embed/tomcat-embed-programmatic.jar:tomcat-embedded-sample.jar \
 org.apache.catalina.startup.EmbeddedTomcat
 
 cd $CURDIR

res/graal/build-tomcat-native-image.sh

@@ -0,0 +1,281 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.tomcat.util.xreflection;
+
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.net.InetAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.apache.tomcat.util.IntrospectionUtils;
+
+public final class ObjectReflectionPropertyInspector {
+
+    public static void main(String... args) throws Exception {
+        if (args.length == 0) {
+            System.err.println("Usage:\n\t"+
+                "org.apache.tomcat.util.xreflection.ObjectReflectionPropertyInspector" +
+                " <destination directory>"
+            );
+            System.exit(1);
+        }
+
+        File outputDir = new File(args[0]);
+        if (!outputDir.exists() || !outputDir.isDirectory()) {
+            System.err.println("Invalid output directory: "+ outputDir.getAbsolutePath());
+            System.exit(1);
+        }
+
+
+        Set<SetPropertyClass> baseClasses = getKnownClasses()
+            .stream()
+            .map(c -> processClass(c))
+            .collect(Collectors.toSet());
+        generateCode(
+            baseClasses,
+            "org.apache.tomcat.util",
+            outputDir,
+            "XReflectionIntrospectionUtils"
+        );
+    }
+
+    private static final Set<Class<?>> getKnownClasses() throws ClassNotFoundException {
+        return
+            Collections.unmodifiableSet(new HashSet<>(
+                    Arrays.asList(
+                        Class.forName("org.apache.catalina.authenticator.jaspic.SimpleAuthConfigProvider"),
+                        Class.forName("org.apache.catalina.authenticator.jaspic.PersistentProviderRegistrations$Property"),
+                        Class.forName("org.apache.catalina.authenticator.jaspic.PersistentProviderRegistrations$Provider"),
+                        Class.forName("org.apache.catalina.connector.Connector"),
+                        Class.forName("org.apache.catalina.core.AprLifecycleListener"),
+                        Class.forName("org.apache.catalina.core.ContainerBase"),
+                        Class.forName("org.apache.catalina.core.StandardContext"),
+                        Class.forName("org.apache.catalina.core.StandardEngine"),
+                        Class.forName("org.apache.catalina.core.StandardHost"),
+                        Class.forName("org.apache.catalina.core.StandardServer"),
+                        Class.forName("org.apache.catalina.core.StandardService"),
+                        Class.forName("org.apache.catalina.filters.AddDefaultCharsetFilter"),
+                        Class.forName("org.apache.catalina.filters.RestCsrfPreventionFilter"),
+                        Class.forName("org.apache.catalina.loader.ParallelWebappClassLoader"),
+                        Class.forName("org.apache.catalina.loader.WebappClassLoaderBase"),
+                        Class.forName("org.apache.catalina.realm.UserDatabaseRealm"),
+                        Class.forName("org.apache.catalina.valves.AccessLogValve"),
+                        Class.forName("org.apache.coyote.AbstractProtocol"),
+                        Class.forName("org.apache.coyote.ajp.AbstractAjpProtocol"),
+                        Class.forName("org.apache.coyote.ajp.AjpAprProtocol"),
+                        Class.forName("org.apache.coyote.ajp.AjpNio2Protocol"),
+                        Class.forName("org.apache.coyote.ajp.AjpNioProtocol"),
+                        Class.forName("org.apache.coyote.http11.AbstractHttp11JsseProtocol"),
+                        Class.forName("org.apache.coyote.http11.AbstractHttp11Protocol"),
+                        Class.forName("org.apache.coyote.http11.Http11AprProtocol"),
+                        Class.forName("org.apache.coyote.http11.Http11Nio2Protocol"),
+                        Class.forName("org.apache.coyote.http11.Http11NioProtocol"),
+                        Class.forName("org.apache.tomcat.util.descriptor.web.ContextResource"),
+                        Class.forName("org.apache.tomcat.util.descriptor.web.ResourceBase"),
+                        Class.forName("org.apache.tomcat.util.modeler.AttributeInfo"),
+                        Class.forName("org.apache.tomcat.util.modeler.FeatureInfo"),
+                        Class.forName("org.apache.tomcat.util.modeler.ManagedBean"),
+                        Class.forName("org.apache.tomcat.util.modeler.OperationInfo"),
+                        Class.forName("org.apache.tomcat.util.modeler.ParameterInfo"),
+                        Class.forName("org.apache.tomcat.util.net.AbstractEndpoint"),
+                        Class.forName("org.apache.tomcat.util.net.AprEndpoint"),
+                        Class.forName("org.apache.tomcat.util.net.Nio2Endpoint"),
+                        Class.forName("org.apache.tomcat.util.net.NioEndpoint"),
+                        Class.forName("org.apache.tomcat.util.net.SocketProperties")
+                    )
+                )
+            );
+    }
+
+    //types of properties that IntrospectionUtils.setProperty supports
+    private static final Set<Class<?>> ALLOWED_TYPES = Collections.unmodifiableSet(new HashSet<>(
+        Arrays.asList(
+            Boolean.TYPE,
+            Integer.TYPE,
+            Long.TYPE,
+            String.class,
+            InetAddress.class
+        )
+    ));
+    private static Map<Class<?>, SetPropertyClass> classes = new HashMap<>();
+
+    public static void generateCode(Set<SetPropertyClass> baseClasses, String packageName, File location, String className) throws Exception {
+        String packageDirectory = packageName.replace('.','/');
+        File sourceFileLocation = new File(location, packageDirectory);
+        ReflectionLessCodeGenerator.generateCode(sourceFileLocation, className, packageName, baseClasses);
+    }
+
+
+    private static boolean isAllowedField(Field field) {
+        return ALLOWED_TYPES.contains(field.getType()) && !Modifier.isFinal(field.getModifiers());
+    }
+
+    private static boolean isAllowedSetMethod(Method method) {
+        return method.getName().startsWith("set") &&
+            method.getParameterTypes() != null &&
+            method.getParameterTypes().length == 1 &&
+            ALLOWED_TYPES.contains(method.getParameterTypes()[0]) &&
+            !Modifier.isPrivate(method.getModifiers());
+    }
+
+    private static boolean isAllowedGetMethod(Method method) {
+        return (method.getName().startsWith("get") || method.getName().startsWith("is")) &&
+            (method.getParameterTypes() == null ||
+            method.getParameterTypes().length == 0) &&
+            ALLOWED_TYPES.contains(method.getReturnType()) &&
+            !Modifier.isPrivate(method.getModifiers());
+    }
+
+
+    private static SetPropertyClass getOrCreateSetPropertyClass(Class<?> clazz) {
+        boolean base = (clazz.getSuperclass() == null || clazz.getSuperclass() == Object.class);
+        SetPropertyClass spc = classes.get(clazz);
+        if (spc == null) {
+            spc = new SetPropertyClass(clazz, base ? null : getOrCreateSetPropertyClass(clazz.getSuperclass()));
+            classes.put(clazz, spc);
+        }
+        return spc;
+    }
+
+    static Method findGetter(Class<?> declaringClass, String propertyName) {
+        for (String getterName : Arrays.asList("get" + IntrospectionUtils.capitalize(propertyName), "is" + propertyName)) {
+            try {
+                Method method = declaringClass.getMethod(getterName);
+                if (!Modifier.isPrivate(method.getModifiers())) {
+                    return method;
+                }
+            } catch (NoSuchMethodException e) {
+            }
+        }
+        try {
+            Method method = declaringClass.getMethod("getProperty", String.class, String.class);
+            if (!Modifier.isPrivate(method.getModifiers())) {
+                return method;
+            }
+        } catch (NoSuchMethodException e) {
+        }
+
+        return null;
+    }
+
+    static Method findSetter(Class<?> declaringClass, String propertyName, Class<?> propertyType) {
+        try {
+            Method method = declaringClass.getMethod("set" + IntrospectionUtils.capitalize(propertyName), propertyType);
+            if (!Modifier.isPrivate(method.getModifiers())) {
+                return method;
+            }
+        } catch (NoSuchMethodException e) {
+        }
+        try {
+            Method method = declaringClass.getMethod("setProperty", String.class, String.class);
+            if (!Modifier.isPrivate(method.getModifiers())) {
+                return method;
+            }
+        } catch (NoSuchMethodException e) {
+        }
+        return null;
+    }
+
+    static String decapitalize(String name) {
+        if (name == null || name.length() == 0) {
+            return name;
+        }
+        if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
+            Character.isUpperCase(name.charAt(0))) {
+            return name;
+        }
+        char chars[] = name.toCharArray();
+        chars[0] = Character.toLowerCase(chars[0]);
+        return new String(chars);
+    }
+
+
+    static SetPropertyClass processClass(Class<?> clazz) {
+        SetPropertyClass spc = getOrCreateSetPropertyClass(clazz);
+        final Method[] methods = clazz.getDeclaredMethods();
+        for (Method method : methods) {
+            if (isAllowedSetMethod(method)) {
+                String propertyName = decapitalize(method.getName().substring(3));
+                Class<?> propertyType = method.getParameterTypes()[0];
+                Method getter = findGetter(clazz, propertyName);
+                Method setter = findSetter(clazz, propertyName, propertyType);
+                ReflectionProperty property = new ReflectionProperty(
+                    spc.getClazz().getName(),
+                    propertyName,
+                    propertyType,
+                    setter,
+                    getter
+                );
+                spc.addProperty(property);
+            } else if (isAllowedGetMethod(method)) {
+                boolean startsWithIs = method.getName().startsWith("is");
+                String propertyName = decapitalize(method.getName().substring(startsWithIs ? 2 : 3));
+                Class<?> propertyType = method.getReturnType();
+                Method getter = findGetter(clazz, propertyName);
+                Method setter = findSetter(clazz, propertyName, propertyType);
+                ReflectionProperty property = new ReflectionProperty(
+                    spc.getClazz().getName(),
+                    propertyName,
+                    propertyType,
+                    setter,
+                    getter
+                );
+                spc.addProperty(property);
+            }
+        }
+
+        final Field[] fields = clazz.getDeclaredFields();
+        for (Field field : fields) {
+            if (isAllowedField(field)) {
+                Method getter = findGetter(
+                    field.getDeclaringClass(),
+                    IntrospectionUtils.capitalize(field.getName())
+                );
+                Method setter = findSetter(
+                    field.getDeclaringClass(),
+                    IntrospectionUtils.capitalize(field.getName()),
+                    field.getType()
+                );
+                ReflectionProperty property = new ReflectionProperty(
+                    spc.getClazz().getName(),
+                    field.getName(),
+                    field.getType(),
+                    setter,
+                    getter
+                );
+                spc.addProperty(property);
+            }
+        }
+
+        if (!spc.isBaseClass()) {
+            SetPropertyClass parent = getOrCreateSetPropertyClass(spc.getClazz().getSuperclass());
+            parent.addSubClass(spc);
+            return processClass(parent.getClazz());
+        } else {
+            return spc;
+        }
+    }
+}