feat: add support for native image build

Adds support for native image build by registering classes for reflection and
patching Atmosphere.

Fixes #157

Author: mcollovati

deployment/src/main/java/com/vaadin/quarkus/deployment/VaadinQuarkusNativeProcessor.java

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2000-2025 Vaadin Ltd.
+ *
+ * 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.vaadin.quarkus.deployment.nativebuild;
+
+import java.util.HashMap;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.function.Predicate;
+
+import io.quarkus.gizmo.Gizmo;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.InsnNode;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+
+/**
+ * Patches Atmosphere {@code InjectableObjectFactory} to remove the
+ * {@code injectableServiceLoader} field and its initialization that is causing
+ * issue during STATIC_INIT phase in native build, and replaces field usages
+ * with a direct calls to {@code ServiceLoader.load(Injectable.class)}.
+ */
+final class InjectableObjectFactoryFieldUsageRemovalMethodVisitor
+        extends MethodNode {
+    public InjectableObjectFactoryFieldUsageRemovalMethodVisitor(
+            MethodVisitor mv, int access, String name, String descriptor,
+            String signature, String[] exceptions) {
+        super(Gizmo.ASM_API_VERSION, access, name, descriptor, signature,
+                exceptions);
+        this.mv = mv;
+    }
+
+    @Override
+    public void visitEnd() {
+        ListIterator<AbstractInsnNode> iterator = instructions.iterator();
+        Map<AbstractInsnNode, AbstractInsnNode> nodesToReplace = new HashMap<>();
+
+        FieldInsnNode fieldUsage;
+        while ((fieldUsage = findFieldUsage(iterator)) != null) {
+            if (fieldUsage.getOpcode() == Opcodes.PUTFIELD) {
+                /*
+                 * Remove injectableServiceLoader initialization
+                 *
+                 * L6 LINENUMBER 66 L6 ALOAD 0 LDC
+                 * Lorg/atmosphere/inject/Injectable;.class INVOKESTATIC
+                 * java/util/ServiceLoader.load
+                 * (Ljava/lang/Class;)Ljava/util/ServiceLoader; PUTFIELD
+                 * org/atmosphere/inject/InjectableObjectFactory.
+                 * injectableServiceLoader : Ljava/util/ServiceLoader;
+                 */
+                nodesToReplace.put(iterator.previous(),
+                        new InsnNode(Opcodes.NOP)); // PUTFIELD
+                nodesToReplace.put(iterator.previous(),
+                        new InsnNode(Opcodes.NOP)); // INVOKESTATIC
+                nodesToReplace.put(iterator.previous(),
+                        new InsnNode(Opcodes.NOP)); // LDC
+                nodesToReplace.put(iterator.previous(),
+                        new InsnNode(Opcodes.NOP)); // ALOAD
+
+                AbstractInsnNode stop = fieldUsage;
+                findNextNode(iterator, n -> n == stop);
+            } else if (fieldUsage.getOpcode() == Opcodes.GETFIELD) {
+                /*
+                 * Replaces usage of injectableServiceLoader field with a call
+                 * to ServiceLoader.load(Injectable.class)
+                 *
+                 * L13 LINENUMBER 86 L13 FRAME FULL
+                 * [org/atmosphere/inject/InjectableObjectFactory
+                 * org/atmosphere/cpr/AtmosphereConfig java/lang/String] []
+                 * ALOAD 0 GETFIELD
+                 * org/atmosphere/inject/InjectableObjectFactory.
+                 * injectableServiceLoader : Ljava/util/ServiceLoader;
+                 * INVOKEVIRTUAL java/util/ServiceLoader.iterator
+                 * ()Ljava/util/Iterator; ASTORE 3
+                 */
+                nodesToReplace.put(iterator.previous(), new MethodInsnNode(
+                        Opcodes.INVOKESTATIC, "java/util/ServiceLoader", "load",
+                        "(Ljava/lang/Class;)Ljava/util/ServiceLoader;", false)); // GETFIELD
+                nodesToReplace.put(iterator.previous(), new LdcInsnNode(
+                        Type.getType("Lorg/atmosphere/inject/Injectable;"))); // ALOAD
+                AbstractInsnNode stop = fieldUsage;
+                findNextNode(iterator, n -> n == stop);
+            }
+        }
+        nodesToReplace.forEach(instructions::set);
+        instructions.resetLabels();
+        accept(mv);
+    }
+
+    private FieldInsnNode findFieldUsage(
+            ListIterator<AbstractInsnNode> iterator) {
+        return (FieldInsnNode) findNextNode(iterator,
+                node -> node instanceof FieldInsnNode field
+                        && field.name.equals("injectableServiceLoader"));
+    }
+
+    private AbstractInsnNode findNextNode(
+            ListIterator<AbstractInsnNode> iterator,
+            Predicate<AbstractInsnNode> test) {
+        while (iterator.hasNext()) {
+            AbstractInsnNode node = iterator.next();
+            if (test.test(node)) {
+                return node;
+            }
+        }
+        return null;
+    }
+}

deployment/src/main/java/com/vaadin/quarkus/deployment/nativebuild/AtmospherePatches.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2000-2025 Vaadin Ltd.
+ *
+ * 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.vaadin.quarkus.graal;
+
+import jakarta.servlet.ServletConfig;
+import jakarta.servlet.ServletContext;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.atmosphere.cpr.AtmosphereFramework;
+
+/**
+ * Defers the initialization of executors at runtime to prevent failures during
+ * native build.
+ */
+public class AtmosphereDeferredInitializer {
+
+    transient List<AtmosphereFramework> frameworks = new ArrayList<>();
+
+    /**
+     * Called by @Recorder at RUNTIME_INIT to complete deferred Atmosphere
+     * initialization that cannot be performed at build time (e.g. starting
+     * thread pools).
+     *
+     * @param servletContext
+     *            the servlet context.
+     */
+    static void completeInitialization(ServletContext servletContext) {
+        AtmosphereDeferredInitializer initializer = getOrCreateInitializer(
+                servletContext);
+        initializer.frameworks.forEach(DelayedInitBroadcaster::startExecutors);
+    }
+
+    /**
+     * Takes a reference to an Atmosphere instance to defer the initialization
+     * of Atmosphere at RUNTIME_INIT phase. The effective initialization is
+     * performed by the AtmosphereDeferredInitializerRecorder @Recoder.
+     *
+     * @param config
+     *            the servlet config.
+     * @param framework
+     *            the Atmosphere framework instance.
+     */
+    public static void register(ServletConfig config,
+            AtmosphereFramework framework) {
+        ServletContext context = config.getServletContext();
+        AtmosphereDeferredInitializer initializer = getOrCreateInitializer(
+                context);
+        initializer.frameworks.add(framework);
+    }
+
+    private static AtmosphereDeferredInitializer getOrCreateInitializer(
+            ServletContext context) {
+        AtmosphereDeferredInitializer initializer = (AtmosphereDeferredInitializer) context
+                .getAttribute(AtmosphereDeferredInitializer.class.getName());
+        if (initializer == null) {
+            initializer = new AtmosphereDeferredInitializer();
+            context.setAttribute(AtmosphereDeferredInitializer.class.getName(),
+                    initializer);
+        }
+        return initializer;
+    }
+}

deployment/src/main/java/com/vaadin/quarkus/deployment/nativebuild/InjectableObjectFactoryFieldUsageRemovalMethodVisitor.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2000-2025 Vaadin Ltd.
+ *
+ * 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.vaadin.quarkus.graal;
+
+import io.quarkus.runtime.annotations.Recorder;
+import io.undertow.servlet.api.DeploymentManager;
+
+/**
+ * Initializes the Atmosphere framework at RUNTIME_INIT phase.
+ */
+@Recorder
+public class AtmosphereDeferredInitializerRecorder {
+
+    public void initAtmosphere(DeploymentManager deploymentManager) {
+        AtmosphereDeferredInitializer.completeInitialization(
+                deploymentManager.getDeployment().getServletContext());
+    }
+}

runtime/src/main/java/com/vaadin/quarkus/graal/AtmosphereDeferredInitializer.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2000-2025 Vaadin Ltd.
+ *
+ * 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.vaadin.quarkus.graal;
+
+import jakarta.servlet.ServletConfig;
+import jakarta.servlet.ServletContext;
+import java.util.Enumeration;
+
+import org.atmosphere.cpr.ApplicationConfig;
+
+/**
+ * A {@link ServletConfig} wrapper that forces the usage of
+ * {@link DelayedInitBroadcaster} to prevent executors to be started during
+ * static init in a native build.
+ */
+public class AtmosphereServletConfig implements ServletConfig {
+
+    private final ServletConfig delegate;
+
+    public AtmosphereServletConfig(ServletConfig delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public String getServletName() {
+        return delegate.getServletName();
+    }
+
+    @Override
+    public ServletContext getServletContext() {
+        return delegate.getServletContext();
+    }
+
+    @Override
+    public String getInitParameter(String name) {
+        if (ApplicationConfig.BROADCASTER_CLASS.equals(name)) {
+            return DelayedInitBroadcaster.class.getName();
+        }
+        return delegate.getInitParameter(name);
+    }
+
+    @Override
+    public Enumeration<String> getInitParameterNames() {
+        return delegate.getInitParameterNames();
+    }
+}

runtime/src/main/java/com/vaadin/quarkus/graal/AtmosphereDeferredInitializerRecorder.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2000-2025 Vaadin Ltd.
+ *
+ * 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.vaadin.quarkus.graal;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.atmosphere.cpr.AtmosphereConfig;
+import org.atmosphere.cpr.AtmosphereFramework;
+import org.atmosphere.cpr.BroadcasterConfig;
+import org.atmosphere.cpr.DefaultBroadcaster;
+
+/**
+ * A broadcaster implementation that postpone schedulers initialization.
+ * <p>
+ * </p>
+ * Usually initialization is performed during Atmosphere init() call, but this
+ * prevents a native build to complete because starting threads at build time is
+ * not supported. Postponed initialization is activated by a call to
+ * {@link #startExecutors(AtmosphereFramework)}.
+ */
+public class DelayedInitBroadcaster extends DefaultBroadcaster {
+
+    private final AtomicBoolean executorsInitialized = new AtomicBoolean(false);
+
+    @Override
+    protected BroadcasterConfig createBroadcasterConfig(
+            AtmosphereConfig config) {
+        return new DelayedInitBroadcasterConfig(
+                config.framework().broadcasterFilters(), config, getID())
+                        .init();
+    }
+
+    @Override
+    protected void spawnReactor() {
+        if (executorsInitialized.get()) {
+            super.spawnReactor();
+        }
+    }
+
+    @Override
+    protected void start() {
+        if (!started.getAndSet(true)) {
+            if (executorsInitialized.get()) {
+                super.start();
+            }
+        }
+    }
+
+    void delayedInit() {
+        if (getBroadcasterConfig()instanceof DelayedInitBroadcasterConfig cfg) {
+            if (executorsInitialized.compareAndSet(false, true)) {
+                cfg.configExecutors();
+                if (started.get()) {
+                    super.start();
+                }
+            }
+        }
+    }
+
+    static void startExecutors(AtmosphereFramework framework) {
+        if (framework != null) {
+            framework.getAtmosphereHandlers().values().stream()
+                    .map(h -> h.broadcaster).filter(Objects::nonNull)
+                    .filter(b -> b instanceof DelayedInitBroadcaster)
+                    .map(DelayedInitBroadcaster.class::cast)
+                    .forEach(DelayedInitBroadcaster::delayedInit);
+        }
+    }
+
+    private static class DelayedInitBroadcasterConfig
+            extends BroadcasterConfig {
+
+        public DelayedInitBroadcasterConfig(List<String> broadcastFilters,
+                AtmosphereConfig config, String broadcasterId) {
+            super(broadcastFilters, config, false, broadcasterId);
+        }
+
+        @Override
+        protected synchronized void configExecutors() {
+            super.configExecutors();
+        }
+    }
+}