Merge pull request #3845 from jGauravGupta/PAYARA-2518

addAnnotatedType now provide ID to prevent warning and provides new variants of CDI extension that allows integrators to prevent warnings regarding scanning all types.

Author: arjantijms

connectors/jetty-connector/src/test/java/org/glassfish/jersey/jetty/connector/AsyncTest.java

@@ -110,6 +110,8 @@ public void handleTimeout(AsyncResponse asyncResponse) {
                 }
             });
             asyncResponse.setTimeout(1, TimeUnit.SECONDS);
+            asyncResponse.resume(Response.status(Response.Status.SERVICE_UNAVAILABLE)
+                    .entity("Operation time out.").build());
 
             new Thread(new Runnable() {
 

connectors/jetty-connector/src/test/java/org/glassfish/jersey/jetty/connector/HelloWorldTest.java

@@ -71,7 +71,6 @@ protected Application configure() {
 
     @Override
     protected void configureClient(ClientConfig config) {
-        config.property(ClientProperties.ASYNC_THREADPOOL_SIZE, 20);
         config.connectorProvider(new JettyConnectorProvider());
     }
 

ext/cdi/jersey-cdi1x-servlet/src/main/java/org/glassfish/jersey/ext/cdi1x/servlet/internal/CdiExternalRequestScopeExtension.java

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  */
-
+// Portions Copyright [2018] Payara Foundation and/or affiliates
 package org.glassfish.jersey.ext.cdi1x.servlet.internal;
 
 import java.lang.annotation.Annotation;
@@ -57,7 +57,7 @@ public class CdiExternalRequestScopeExtension implements Extension {
      */
     private void beforeBeanDiscovery(@Observes BeforeBeanDiscovery beforeBeanDiscoveryEvent, final BeanManager beanManager) {
         requestScopeType = beanManager.createAnnotatedType(CdiExternalRequestScope.class);
-        beforeBeanDiscoveryEvent.addAnnotatedType(requestScopeType);
+        beforeBeanDiscoveryEvent.addAnnotatedType(requestScopeType, "Jersey " + CdiExternalRequestScope.class.getName());
     }
 
     /**

ext/cdi/jersey-cdi1x-transaction/src/main/java/org/glassfish/jersey/ext/cdi1x/transaction/internal/TransactionalExceptionInterceptorProvider.java

@@ -16,14 +16,17 @@
 
 package org.glassfish.jersey.ext.cdi1x.transaction.internal;
 
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 import java.util.List;
 import java.util.Set;
 
-import javax.ws.rs.WebApplicationException;
-import javax.ws.rs.ext.ExceptionMapper;
-
 import javax.annotation.Priority;
 import javax.enterprise.event.Observes;
 import javax.enterprise.inject.spi.AfterTypeDiscovery;
@@ -33,6 +36,8 @@
 import javax.inject.Qualifier;
 import javax.interceptor.Interceptor;
 import javax.transaction.TransactionalException;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.ext.ExceptionMapper;
 
 import org.glassfish.jersey.ext.cdi1x.internal.CdiUtil;
 import org.glassfish.jersey.ext.cdi1x.internal.GenericCdiBeanSupplier;
@@ -41,12 +46,6 @@
 import org.glassfish.jersey.internal.inject.InjectionManager;
 import org.glassfish.jersey.server.spi.ComponentProvider;
 
-import static java.lang.annotation.ElementType.FIELD;
-import static java.lang.annotation.ElementType.METHOD;
-import static java.lang.annotation.ElementType.PARAMETER;
-import static java.lang.annotation.ElementType.TYPE;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
 /**
  * Jersey CDI extension that provides means to retain {@link WebApplicationException}
  * thrown from JAX-RS components implemented as CDI transactional beans.
@@ -100,10 +99,17 @@ private void afterTypeDiscovery(@Observes final AfterTypeDiscovery afterTypeDisc
     }
 
     @SuppressWarnings("unused")
-    private void beforeBeanDiscovery(@Observes final BeforeBeanDiscovery beforeBeanDiscovery, final javax.enterprise.inject.spi
-            .BeanManager beanManager) {
-        beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(WebAppExceptionHolder.class));
-        beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(WebAppExceptionInterceptor.class));
-        beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(TransactionalExceptionMapper.class));
+    private void beforeBeanDiscovery(@Observes BeforeBeanDiscovery beforeBeanDiscovery, BeanManager beanManager) {
+        addAnnotatedTypes(beforeBeanDiscovery, beanManager,
+                WebAppExceptionHolder.class,
+                WebAppExceptionInterceptor.class,
+                TransactionalExceptionMapper.class
+        );
+    }
+
+    private static void addAnnotatedTypes(BeforeBeanDiscovery beforeBeanDiscovery, BeanManager beanManager, Class<?>... types) {
+        for (Class<?> type : types) {
+            beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(type), "Jersey " + type.getName());
+        }
     }
 }

ext/cdi/jersey-cdi1x/src/main/java/org/glassfish/jersey/ext/cdi1x/internal/CdiComponentProvider.java

@@ -448,8 +448,72 @@ public boolean isAnnotationPresent(final Class<? extends Annotation> annotationT
         };
     }
 
+    private boolean containsJaxRsParameterizedCtor(final AnnotatedType annotatedType) {
+        return containAnnotatedParameters(annotatedType.getConstructors(), JaxRsParamProducer.JAX_RS_STRING_PARAM_ANNOTATIONS);
+    }
+
+    private boolean containsJaxRsConstructorInjection(final AnnotatedType annotatedType) {
+        return containAnnotatedParameters(annotatedType.getConstructors(), JAX_RS_INJECT_ANNOTATIONS);
+    }
+
+    private boolean containsJaxRsMethodInjection(final AnnotatedType annotatedType) {
+        return containAnnotatedParameters(annotatedType.getMethods(), JAX_RS_INJECT_ANNOTATIONS);
+    }
+
+    private boolean containsJaxRsFieldInjection(final AnnotatedType annotatedType) {
+        return containAnnotation(annotatedType.getFields(), JAX_RS_INJECT_ANNOTATIONS);
+    }
+
+    private boolean containAnnotatedParameters(final Collection<AnnotatedCallable> annotatedCallables,
+                                               final Set<Class<? extends Annotation>> annotationSet) {
+        for (final AnnotatedCallable c : annotatedCallables) {
+            if (containAnnotation(c.getParameters(), annotationSet)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean containAnnotation(final Collection<Annotated> elements,
+                                      final Set<Class<? extends Annotation>> annotationSet) {
+        for (final Annotated element : elements) {
+            if (hasAnnotation(element, annotationSet)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean hasAnnotation(final Annotated element, final Set<Class<? extends Annotation>> annotations) {
+        for (final Class<? extends Annotation> a : annotations) {
+            if (element.isAnnotationPresent(a)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     @SuppressWarnings("unused")
-    private void processAnnotatedType(@Observes
+    private void afterTypeDiscovery(@Observes final AfterTypeDiscovery afterTypeDiscovery) {
+        if (LOGGER.isLoggable(Level.CONFIG) && !jerseyVetoedTypes.isEmpty()) {
+            LOGGER.config(LocalizationMessages.CDI_TYPE_VETOED(customHk2TypesProvider,
+                    listElements(new StringBuilder().append("\n"), jerseyVetoedTypes).toString()));
+        }
+    }
+
+    @SuppressWarnings("unused")
+    private void beforeBeanDiscovery(@Observes final BeforeBeanDiscovery beforeBeanDiscovery, final BeanManager beanManager) {
+        beforeBeanDiscovery.addAnnotatedType(
+            beanManager.createAnnotatedType(JaxRsParamProducer.class),
+            "Jersey " + JaxRsParamProducer.class.getName()
+        );
+        beforeBeanDiscovery.addAnnotatedType(
+            beanManager.createAnnotatedType(ProcessJAXRSAnnotatedTypes.class),
+            "Jersey " + ProcessJAXRSAnnotatedTypes.class.getName()
+        );
+    }
+
+    public void processAnnotatedType(//@Observes
     // We can not apply the following constraint
     // if we want to fully support {@link org.glassfish.jersey.ext.cdi1x.spi.Hk2CustomBoundTypesProvider}.
     // Covered by tests/integration/cdi-with-jersey-injection-custom-cfg-webapp test application:
@@ -535,64 +599,6 @@ public boolean isAnnotationPresent(final Class<? extends Annotation> annotationT
         }
     }
 
-    private boolean containsJaxRsParameterizedCtor(final AnnotatedType annotatedType) {
-        return containAnnotatedParameters(annotatedType.getConstructors(), JaxRsParamProducer.JAX_RS_STRING_PARAM_ANNOTATIONS);
-    }
-
-    private boolean containsJaxRsConstructorInjection(final AnnotatedType annotatedType) {
-        return containAnnotatedParameters(annotatedType.getConstructors(), JAX_RS_INJECT_ANNOTATIONS);
-    }
-
-    private boolean containsJaxRsMethodInjection(final AnnotatedType annotatedType) {
-        return containAnnotatedParameters(annotatedType.getMethods(), JAX_RS_INJECT_ANNOTATIONS);
-    }
-
-    private boolean containsJaxRsFieldInjection(final AnnotatedType annotatedType) {
-        return containAnnotation(annotatedType.getFields(), JAX_RS_INJECT_ANNOTATIONS);
-    }
-
-    private boolean containAnnotatedParameters(final Collection<AnnotatedCallable> annotatedCallables,
-                                               final Set<Class<? extends Annotation>> annotationSet) {
-        for (final AnnotatedCallable c : annotatedCallables) {
-            if (containAnnotation(c.getParameters(), annotationSet)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private boolean containAnnotation(final Collection<Annotated> elements,
-                                      final Set<Class<? extends Annotation>> annotationSet) {
-        for (final Annotated element : elements) {
-            if (hasAnnotation(element, annotationSet)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private static boolean hasAnnotation(final Annotated element, final Set<Class<? extends Annotation>> annotations) {
-        for (final Class<? extends Annotation> a : annotations) {
-            if (element.isAnnotationPresent(a)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @SuppressWarnings("unused")
-    private void afterTypeDiscovery(@Observes final AfterTypeDiscovery afterTypeDiscovery) {
-        if (LOGGER.isLoggable(Level.CONFIG) && !jerseyVetoedTypes.isEmpty()) {
-            LOGGER.config(LocalizationMessages.CDI_TYPE_VETOED(customHk2TypesProvider,
-                    listElements(new StringBuilder().append("\n"), jerseyVetoedTypes).toString()));
-        }
-    }
-
-    @SuppressWarnings("unused")
-    private void beforeBeanDiscovery(@Observes final BeforeBeanDiscovery beforeBeanDiscovery,
-            final javax.enterprise.inject.spi.BeanManager beanManager) {
-        beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(JaxRsParamProducer.class));
-    }
 
     @SuppressWarnings("unused")
     private void processInjectionTarget(@Observes final ProcessInjectionTarget event) {

ext/cdi/jersey-cdi1x/src/main/java/org/glassfish/jersey/ext/cdi1x/internal/ProcessAllAnnotatedTypes.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2018 Payara Foundation and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * https://github.com/payara/Payara/blob/master/LICENSE.txt
+ * See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at glassfish/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * The Payara Foundation designates this particular file as subject to the "Classpath"
+ * exception as provided by the Payara Foundation in the GPL Version 2 section of the License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package org.glassfish.jersey.ext.cdi1x.internal;
+
+import javax.enterprise.event.Observes;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.Extension;
+import javax.enterprise.inject.spi.ProcessAnnotatedType;
+
+public class ProcessAllAnnotatedTypes implements Extension {
+
+    public void processAnnotatedType(@Observes ProcessAnnotatedType<?> processAnnotatedType, BeanManager beanManager) {
+        CdiComponentProvider cdiComponentProvider = beanManager.getExtension(CdiComponentProvider.class);
+        cdiComponentProvider.processAnnotatedType(processAnnotatedType);
+    }
+
+}

ext/cdi/jersey-cdi1x/src/main/java/org/glassfish/jersey/ext/cdi1x/internal/ProcessJAXRSAnnotatedTypes.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2017-2018 Payara Foundation and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * https://github.com/payara/Payara/blob/master/LICENSE.txt
+ * See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at glassfish/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * The Payara Foundation designates this particular file as subject to the "Classpath"
+ * exception as provided by the Payara Foundation in the GPL Version 2 section of the License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package org.glassfish.jersey.ext.cdi1x.internal;
+
+import javax.enterprise.event.Observes;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.Extension;
+import javax.enterprise.inject.spi.ProcessAnnotatedType;
+import javax.enterprise.inject.spi.WithAnnotations;
+import javax.ws.rs.ApplicationPath;
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.MatrixParam;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
+
+public class ProcessJAXRSAnnotatedTypes implements Extension {
+
+    public void processAnnotatedType(
+            @Observes
+            @WithAnnotations({
+                  Context.class,
+                  ApplicationPath.class,
+                  HeaderParam.class,
+                  QueryParam.class,
+                  FormParam.class,
+                  MatrixParam.class,
+                  BeanParam.class,
+                  PathParam.class})
+            ProcessAnnotatedType<?> processAnnotatedType, BeanManager beanManager) {
+
+        beanManager.getExtension(CdiComponentProvider.class)
+                   .processAnnotatedType(processAnnotatedType);
+    }
+
+}

ext/cdi/jersey-cdi1x/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension

@@ -1 +1,2 @@
 org.glassfish.jersey.ext.cdi1x.internal.CdiComponentProvider
+org.glassfish.jersey.ext.cdi1x.internal.ProcessAllAnnotatedTypes