Merge pull request #32407 from manovotn/arcTckFixes

Arc CDI TCK related fixes, focused around behavior gated behind strict mode

Author: mkouba

extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/ArcProcessor.java

@@ -637,9 +637,9 @@ public void registerSubclass(DotName beanClassName, String subclassName) {
             reflectiveClasses
                     .produce(ReflectiveClassBuildItem.builder(binding.name().toString()).methods().build());
         }
-
         ArcContainer container = recorder.initContainer(shutdown,
-                currentContextFactory.isPresent() ? currentContextFactory.get().getFactory() : null);
+                currentContextFactory.isPresent() ? currentContextFactory.get().getFactory() : null,
+                config.strictCompatibility);
         BeanContainer beanContainer = recorder.initBeanContainer(container,
                 beanContainerListenerBuildItems.stream().map(BeanContainerListenerBuildItem::getBeanContainerListener)
                         .collect(Collectors.toList()));

extensions/arc/runtime/src/main/java/io/quarkus/arc/runtime/ArcRecorder.java

@@ -15,6 +15,7 @@
 
 import io.quarkus.arc.Arc;
 import io.quarkus.arc.ArcContainer;
+import io.quarkus.arc.ArcInitConfig;
 import io.quarkus.arc.CurrentContextFactory;
 import io.quarkus.arc.InjectableBean;
 import io.quarkus.arc.InjectableBean.Kind;
@@ -40,9 +41,12 @@ public class ArcRecorder {
      */
     public static volatile Map<String, Function<SyntheticCreationalContext<?>, ?>> syntheticBeanProviders;
 
-    public ArcContainer initContainer(ShutdownContext shutdown, RuntimeValue<CurrentContextFactory> currentContextFactory)
+    public ArcContainer initContainer(ShutdownContext shutdown, RuntimeValue<CurrentContextFactory> currentContextFactory,
+            boolean strictCompatibility)
             throws Exception {
-        ArcContainer container = Arc.initialize(currentContextFactory != null ? currentContextFactory.getValue() : null);
+        ArcContainer container = Arc.initialize(ArcInitConfig.builder()
+                .setCurrentContextFactory(currentContextFactory != null ? currentContextFactory.getValue() : null)
+                .setStrictCompatibility(strictCompatibility).build());
         shutdown.addShutdownTask(new Runnable() {
             @Override
             public void run() {

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanDeployment.java

@@ -938,8 +938,14 @@ private List<BeanInfo> findBeans(Collection<DotName> beanDefiningAnnotations, Li
                     }
                 }
 
-                // a bean without no-arg constructor needs to have either a constructor annotated with @Inject
-                // or a single constructor
+                // in strict compatibility mode, the bean needs to have either no args ctor or some with @Inject
+                // note that we perform validation (for multiple ctors for instance) later in the cycle
+                if (strictCompatibility && numberOfConstructorsWithInject == 0) {
+                    continue;
+                }
+
+                // without strict compatibility, a bean without no-arg constructor needs to have either a constructor
+                // annotated with @Inject or a single constructor
                 if (numberOfConstructorsWithInject == 0 && numberOfConstructorsWithoutInject != 1) {
                     continue;
                 }
@@ -982,12 +988,19 @@ private List<BeanInfo> findBeans(Collection<DotName> beanDefiningAnnotations, Li
                 }
                 if (annotationStore.hasAnnotation(method, DotNames.PRODUCES)
                         && !annotationStore.hasAnnotation(method, DotNames.VETOED_PRODUCER)) {
+                    // Do not register classes with producers and no bean def. annotation as beans in strict mode
                     // Producers are not inherited
-                    producerMethods.add(method);
-                    if (!hasBeanDefiningAnnotation) {
-                        LOGGER.debugf("Producer method found but %s has no bean defining annotation - using @Dependent",
-                                beanClass);
-                        beanClasses.add(beanClass);
+                    if (strictCompatibility) {
+                        if (hasBeanDefiningAnnotation) {
+                            producerMethods.add(method);
+                        }
+                    } else {
+                        producerMethods.add(method);
+                        if (!hasBeanDefiningAnnotation) {
+                            LOGGER.debugf("Producer method found but %s has no bean defining annotation - using @Dependent",
+                                    beanClass);
+                            beanClasses.add(beanClass);
+                        }
                     }
                 }
                 if (annotationStore.hasAnnotation(method, DotNames.DISPOSES)) {
@@ -1025,23 +1038,31 @@ private List<BeanInfo> findBeans(Collection<DotName> beanDefiningAnnotations, Li
                     if (annotationStore.hasAnnotation(method, DotNames.OBSERVES)) {
                         syncObserverMethods.computeIfAbsent(method, ignored -> new HashSet<>())
                                 .add(beanClass);
+                        // add only concrete classes
                         if (!Modifier.isAbstract(beanClass.flags())) {
-                            // add only concrete classes
-                            beanClasses.add(beanClass);
-                            if (!hasBeanDefiningAnnotation) {
-                                LOGGER.debugf("Observer method found but %s has no bean defining annotation - using @Dependent",
-                                        beanClass);
+                            // do not register classes with observers and no bean def. annotation as beans in strict mode
+                            if (!strictCompatibility) {
+                                beanClasses.add(beanClass);
+                                if (!hasBeanDefiningAnnotation) {
+                                    LOGGER.debugf(
+                                            "Observer method found but %s has no bean defining annotation - using @Dependent",
+                                            beanClass);
+                                }
                             }
                         }
                     } else if (annotationStore.hasAnnotation(method, DotNames.OBSERVES_ASYNC)) {
                         asyncObserverMethods.computeIfAbsent(method, ignored -> new HashSet<>())
                                 .add(beanClass);
+                        // add only concrete classes
                         if (!Modifier.isAbstract(beanClass.flags())) {
-                            // add only concrete classes
-                            beanClasses.add(beanClass);
-                            if (!hasBeanDefiningAnnotation) {
-                                LOGGER.debugf("Observer method found but %s has no bean defining annotation - using @Dependent",
-                                        beanClass);
+                            // do not register classes with observers and no bean def. annotation as beans in strict mode
+                            if (!strictCompatibility) {
+                                beanClasses.add(beanClass);
+                                if (!hasBeanDefiningAnnotation) {
+                                    LOGGER.debugf(
+                                            "Observer method found but %s has no bean defining annotation - using @Dependent",
+                                            beanClass);
+                                }
                             }
                         }
                     }
@@ -1059,12 +1080,19 @@ private List<BeanInfo> findBeans(Collection<DotName> beanDefiningAnnotations, Li
                     if (annotationStore.hasAnnotation(field, DotNames.INJECT)) {
                         throw new DefinitionException("Injected field cannot be annotated with @Produces: " + field);
                     }
+                    // Do not register classes with producers and no bean def. annotation as beans in strict mode
                     // Producer fields are not inherited
-                    producerFields.add(field);
-                    if (!hasBeanDefiningAnnotation) {
-                        LOGGER.debugf("Producer field found but %s has no bean defining annotation - using @Dependent",
-                                beanClass);
-                        beanClasses.add(beanClass);
+                    if (strictCompatibility) {
+                        if (hasBeanDefiningAnnotation) {
+                            producerFields.add(field);
+                        }
+                    } else {
+                        producerFields.add(field);
+                        if (!hasBeanDefiningAnnotation) {
+                            LOGGER.debugf("Producer field found but %s has no bean defining annotation - using @Dependent",
+                                    beanClass);
+                            beanClasses.add(beanClass);
+                        }
                     }
                 } else {
                     // Verify that non-producer fields are not annotated with stereotypes

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ObserverGenerator.java

@@ -23,7 +23,6 @@
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
-import jakarta.enterprise.context.ContextNotActiveException;
 import jakarta.enterprise.context.spi.Contextual;
 import jakarta.enterprise.event.Reception;
 import jakarta.enterprise.event.TransactionPhase;
@@ -414,8 +413,8 @@ protected void implementNotify(ObserverInfo observer, ClassCreator observerCreat
                 ResultHandle context = notify.invokeInterfaceMethod(MethodDescriptors.ARC_CONTAINER_GET_ACTIVE_CONTEXT,
                         container,
                         scope);
-                notify.ifNull(context).trueBranch().throwException(ContextNotActiveException.class,
-                        "Context not active: " + observer.getDeclaringBean().getScope().getDotName());
+                // if the context isn't active, don't notify the observer
+                notify.ifNull(context).trueBranch().returnVoid();
                 notify.assign(declaringProviderInstanceHandle,
                         notify.invokeInterfaceMethod(MethodDescriptors.CONTEXT_GET_IF_PRESENT, context,
                                 declaringProviderHandle));

independent-projects/arc/runtime/src/main/java/io/quarkus/arc/Arc.java

@@ -12,23 +12,37 @@ public final class Arc {
 
     private static final AtomicReference<ArcContainerImpl> INSTANCE = new AtomicReference<>();
 
+    /**
+     * Initializes {@link ArcContainer} with default settings.
+     * This is equal to using {@code Arc#initialize(ArcInitConfig.INSTANCE)}
+     *
+     * @return {@link ArcContainer} instance with default configuration
+     */
     public static ArcContainer initialize() {
-        return initialize(null);
+        return initialize(ArcInitConfig.DEFAULT);
     }
 
     /**
+     * Deprecated, will be removed in future iterations.
+     * Users are encouraged to use {@link #initialize(ArcInitConfig)} instead.
      *
      * @param currentContextFactory
      * @return the initialized container
      */
+    @Deprecated(since = "3.0", forRemoval = true)
     public static ArcContainer initialize(CurrentContextFactory currentContextFactory) {
+        return initialize(ArcInitConfig.builder().setCurrentContextFactory(currentContextFactory).build());
+    }
+
+    public static ArcContainer initialize(ArcInitConfig arcInitConfig) {
         ArcContainerImpl container = INSTANCE.get();
         if (container == null) {
             synchronized (INSTANCE) {
                 container = INSTANCE.get();
                 if (container == null) {
                     // Set the container instance first because Arc.container() can be used within ArcContainerImpl.init()
-                    container = new ArcContainerImpl(currentContextFactory);
+                    container = new ArcContainerImpl(arcInitConfig.getCurrentContextFactory(),
+                            arcInitConfig.isStrictCompatibility());
                     INSTANCE.set(container);
                     container.init();
                 }

independent-projects/arc/runtime/src/main/java/io/quarkus/arc/ArcContainer.java

@@ -233,4 +233,12 @@ public interface ArcContainer {
      * @see CurrentContext
      */
     CurrentContextFactory getCurrentContextFactory();
+
+    /**
+     * Indicates whether container runs in strict compatibility mode.
+     * Default value is false.
+     *
+     * @return true is strict mode is enabled, false otherwise.
+     */
+    boolean strictCompatibility();
 }

independent-projects/arc/runtime/src/main/java/io/quarkus/arc/ArcInitConfig.java

@@ -0,0 +1,64 @@
+package io.quarkus.arc;
+
+/**
+ * A configuration object used while initializing Arc, see {@link Arc#initialize()} methods.
+ * Consolidates all configuration objects needed for Arc to initialize, values are initialized to their defaults.
+ *
+ */
+public final class ArcInitConfig {
+
+    /**
+     * Basic instance without any configuration, all values are default
+     */
+    public static final ArcInitConfig DEFAULT = builder().build();
+
+    /**
+     * Obtains a builder for {@link ArcInitConfig}
+     *
+     * @return new instance of the builder
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    private ArcInitConfig(Builder builder) {
+        this.currentContextFactory = builder.currentContextFactory;
+        this.strictCompatibility = builder.strictCompatibility;
+    }
+
+    private final boolean strictCompatibility;
+    private final CurrentContextFactory currentContextFactory;
+
+    public boolean isStrictCompatibility() {
+        return strictCompatibility;
+    }
+
+    public CurrentContextFactory getCurrentContextFactory() {
+        return currentContextFactory;
+    }
+
+    public static class Builder {
+        private boolean strictCompatibility;
+        private CurrentContextFactory currentContextFactory;
+
+        private Builder() {
+            // init all values with their defaults
+            this.strictCompatibility = false;
+            this.currentContextFactory = null;
+        }
+
+        public Builder setStrictCompatibility(boolean strictCompatibility) {
+            this.strictCompatibility = strictCompatibility;
+            return this;
+        }
+
+        public Builder setCurrentContextFactory(CurrentContextFactory currentContextFactory) {
+            this.currentContextFactory = currentContextFactory;
+            return this;
+        }
+
+        public ArcInitConfig build() {
+            return new ArcInitConfig(this);
+        }
+    }
+}

independent-projects/arc/runtime/src/main/java/io/quarkus/arc/InjectableObserverMethod.java

@@ -38,7 +38,7 @@ default TransactionPhase getTransactionPhase() {
 
     @Override
     default Bean<?> getDeclaringBean() {
-        return Arc.container().bean(getDeclaringBeanIdentifier());
+        return getDeclaringBeanIdentifier() != null ? Arc.container().bean(getDeclaringBeanIdentifier()) : null;
     }
 
     default void notify(T event) {

independent-projects/arc/runtime/src/main/java/io/quarkus/arc/impl/ArcContainerImpl.java

@@ -98,7 +98,10 @@ public class ArcContainerImpl implements ArcContainer {
 
     private final CurrentContextFactory currentContextFactory;
 
-    public ArcContainerImpl(CurrentContextFactory currentContextFactory) {
+    private final boolean strictMode;
+
+    public ArcContainerImpl(CurrentContextFactory currentContextFactory, boolean strictMode) {
+        this.strictMode = strictMode;
         id = String.valueOf(ID_GENERATOR.incrementAndGet());
         running = new AtomicBoolean(true);
         List<InjectableBean<?>> beans = new ArrayList<>();
@@ -363,6 +366,11 @@ public CurrentContextFactory getCurrentContextFactory() {
         return currentContextFactory;
     }
 
+    @Override
+    public boolean strictCompatibility() {
+        return strictMode;
+    }
+
     @Override
     public String toString() {
         return "ArcContainerImpl [id=" + id + ", running=" + running + ", beans=" + beans.size() + ", observers="

independent-projects/arc/runtime/src/main/java/io/quarkus/arc/impl/EventImpl.java

@@ -166,7 +166,8 @@ private Notifier<? super T> createNotifier(Class<?> runtimeType) {
 
     static <T> Notifier<T> createNotifier(Class<?> runtimeType, Type eventType, Set<Annotation> qualifiers,
             ArcContainerImpl container, InjectionPoint injectionPoint) {
-        return createNotifier(runtimeType, eventType, qualifiers, container, true, injectionPoint);
+        return createNotifier(runtimeType, eventType, qualifiers, container, !Arc.container().strictCompatibility(),
+                injectionPoint);
     }
 
     static <T> Notifier<T> createNotifier(Class<?> runtimeType, Type eventType, Set<Annotation> qualifiers,
@@ -316,6 +317,7 @@ void notify(T event, ObserverExceptionHandler exceptionHandler, boolean async) {
                 }
 
                 // Non-tx observers notifications
+                // req. context is activated if not in strict mode and not for lifecycle events such as init/shutdown
                 if (activateRequestContext) {
                     ManagedContext requestContext = Arc.container().requestContext();
                     if (requestContext.isActive()) {

independent-projects/arc/tcks/arquillian/src/main/java/io/quarkus/arc/arquillian/ArcDeployableContainer.java

@@ -21,6 +21,7 @@
 
 import io.quarkus.arc.Arc;
 import io.quarkus.arc.ArcContainer;
+import io.quarkus.arc.ArcInitConfig;
 import io.quarkus.arc.InjectableInstance;
 import io.quarkus.arc.InstanceHandle;
 import io.quarkus.arc.arquillian.utils.ClassLoading;
@@ -81,7 +82,8 @@ public ProtocolMetaData deploy(Archive<?> archive) throws DeploymentException {
 
             Thread.currentThread().setContextClassLoader(deploymentClassLoader);
 
-            ArcContainer arcContainer = Arc.initialize();
+            // passing strict mode here allows it to be visible in runtime
+            ArcContainer arcContainer = Arc.initialize(ArcInitConfig.builder().setStrictCompatibility(true).build());
             runningArc.set(arcContainer);
             arcContainer.beanManager().getEvent().fire(new Startup());
 

independent-projects/arc/tcks/cdi-tck-porting-pkg/src/main/java/io/quarkus/arc/tck/porting/ContextsImpl.java

@@ -1,6 +1,8 @@
 package io.quarkus.arc.tck.porting;
 
 import java.lang.annotation.Annotation;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 import jakarta.enterprise.context.Dependent;
 import jakarta.enterprise.context.spi.Context;
@@ -14,13 +16,20 @@
 import io.quarkus.arc.ManagedContext;
 
 public class ContextsImpl implements Contexts<Context> {
+
+    // ConcurrentHashMap is just future-proofing, could be implemented with plain map too
+    private final Map<Context, InjectableContext.ContextState> contextStateMap = new ConcurrentHashMap<>();
+
     @Override
     public void setActive(Context context) {
-        ((ManagedContext) context).activate();
+        // remove the context state we potentially stored, else use null to initiate fresh context
+        ((ManagedContext) context).activate(contextStateMap.remove(context));
     }
 
     @Override
     public void setInactive(Context context) {
+        // save the state of the context
+        contextStateMap.put(context, ((ManagedContext) context).getState());
         ((ManagedContext) context).deactivate();
     }