JERSEY-2517: Create mechanism to automatically register features/providers

   even when autodiscoverable and metainf/services mechanisms are disabled

 - introduced internal SPI ForcedAutoDiscoverable
 - BV, WADL, JSON-P, Monitoring migrated to ForcedAutoDiscoverable
 - added new test + updated older ones
 - note in migration guide

Change-Id: I120f0e695980e90e86085f34b23608d9a3876027
Signed-off-by: Michal Gajdos <[email protected]>

Author: Michal Gajdos

core-client/src/main/java/org/glassfish/jersey/client/ClientConfig.java

@@ -353,7 +353,11 @@ public Set<Object> getInstances() {
         }
 
         public void configureAutoDiscoverableProviders(ServiceLocator locator) {
-            commonConfig.configureAutoDiscoverableProviders(locator);
+            commonConfig.configureAutoDiscoverableProviders(locator, false);
+        }
+
+        public void configureForcedAutoDiscoverableProviders(ServiceLocator locator) {
+            commonConfig.configureAutoDiscoverableProviders(locator, true);
         }
 
         public void configureMetaProviders(ServiceLocator locator) {
@@ -385,6 +389,8 @@ private ClientRuntime initRuntime() {
             if (!CommonProperties.getValue(runtimeCfgState.getProperties(), RuntimeType.CLIENT,
                     CommonProperties.FEATURE_AUTO_DISCOVERY_DISABLE, Boolean.FALSE, Boolean.class)) {
                 runtimeCfgState.configureAutoDiscoverableProviders(locator);
+            } else {
+                runtimeCfgState.configureForcedAutoDiscoverableProviders(locator);
             }
 
             // Configure binders and features.

core-common/src/main/java/org/glassfish/jersey/internal/spi/ForcedAutoDiscoverable.java

@@ -0,0 +1,59 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2014 Oracle 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
+ * http://glassfish.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/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 packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle 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.internal.spi;
+
+/**
+ * A service provider contract for JAX-RS and Jersey components that need to be automatically discovered and registered in
+ * {@link javax.ws.rs.core.Configuration runtime configurations}.
+ * <p/>
+ * A component implementing this contract becomes auto-discoverable by adding a new entry with fully qualified name of its
+ * implementation class name to a {@code org.glassfish.jersey.internal.spi.AutoDiscoverable} file in the {@code
+ * META-INF/services} directory.
+ * <p/>
+ * Implementations of this contract are always {@link #configure(javax.ws.rs.core.FeatureContext) configured} regardless of
+ * values of properties {@link org.glassfish.jersey.CommonProperties#FEATURE_AUTO_DISCOVERY_DISABLE} and
+ * {@link org.glassfish.jersey.CommonProperties#METAINF_SERVICES_LOOKUP_DISABLE}.
+ *
+ * @author Michal Gajdos (michal.gajdos at oracle.com)
+ * @see org.glassfish.jersey.internal.spi.AutoDiscoverable
+ */
+public interface ForcedAutoDiscoverable extends AutoDiscoverable {
+}

core-common/src/main/java/org/glassfish/jersey/model/internal/CommonConfig.java

@@ -43,26 +43,33 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeSet;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import javax.ws.rs.ConstrainedTo;
+import javax.ws.rs.Priorities;
 import javax.ws.rs.RuntimeType;
 import javax.ws.rs.core.Configuration;
 import javax.ws.rs.core.Feature;
 import javax.ws.rs.core.FeatureContext;
 
+import javax.annotation.Priority;
+
 import org.glassfish.jersey.ExtendedConfig;
 import org.glassfish.jersey.internal.LocalizationMessages;
+import org.glassfish.jersey.internal.ServiceFinder;
 import org.glassfish.jersey.internal.inject.Injections;
 import org.glassfish.jersey.internal.inject.Providers;
 import org.glassfish.jersey.internal.spi.AutoDiscoverable;
+import org.glassfish.jersey.internal.spi.ForcedAutoDiscoverable;
 import org.glassfish.jersey.internal.util.PropertiesHelper;
 import org.glassfish.jersey.model.ContractProvider;
 import org.glassfish.jersey.process.Inflector;
@@ -88,7 +95,7 @@ public class CommonConfig implements FeatureContext, ExtendedConfig {
     private static final Logger LOGGER = Logger.getLogger(CommonConfig.class.getName());
     private static final Function<Object, Binder> CAST_TO_BINDER = new Function<Object, Binder>() {
         @Override
-        public Binder apply(Object input) {
+        public Binder apply(final Object input) {
             return Binder.class.cast(input);
         }
     };
@@ -171,7 +178,7 @@ public boolean equals(final Object obj) {
             if (!(obj instanceof FeatureRegistration)) {
                 return false;
             }
-            FeatureRegistration other = (FeatureRegistration) obj;
+            final FeatureRegistration other = (FeatureRegistration) obj;
 
             return (featureClass == other.featureClass)
                     || (feature != null && (feature == other.feature || feature.equals(other.feature)));
@@ -206,7 +213,7 @@ public int hashCode() {
      *                             or not should the component class registration continue
      *                             towards a successful completion.
      */
-    public CommonConfig(RuntimeType type, Predicate<ContractProvider> registrationStrategy) {
+    public CommonConfig(final RuntimeType type, final Predicate<ContractProvider> registrationStrategy) {
         this.type = type;
 
         this.properties = new HashMap<String, Object>();
@@ -291,7 +298,7 @@ public Object getProperty(final String name) {
     }
 
     @Override
-    public boolean isProperty(String name) {
+    public boolean isProperty(final String name) {
         return PropertiesHelper.isProperty(getProperty(name));
     }
 
@@ -311,17 +318,17 @@ public boolean isEnabled(final Feature feature) {
     }
 
     @Override
-    public boolean isRegistered(Object component) {
+    public boolean isRegistered(final Object component) {
         return componentBag.getInstances().contains(component);
     }
 
     @Override
-    public boolean isRegistered(Class<?> componentClass) {
+    public boolean isRegistered(final Class<?> componentClass) {
         return componentBag.getRegistrations().contains(componentClass);
     }
 
     @Override
-    public Map<Class<?>, Integer> getContracts(Class<?> componentClass) {
+    public Map<Class<?>, Integer> getContracts(final Class<?> componentClass) {
         final ContractProvider model = componentBag.getModel(componentClass);
         return (model == null) ? Collections.<Class<?>, Integer>emptyMap() : model.getContractMap();
     }
@@ -439,7 +446,7 @@ public CommonConfig register(final Class<?> componentClass, final Class<?>... co
     }
 
     @Override
-    public CommonConfig register(final Class<?> componentClass, Map<Class<?>, Integer> contracts) {
+    public CommonConfig register(final Class<?> componentClass, final Map<Class<?>, Integer> contracts) {
         checkComponentClassNotNull(componentClass);
         if (componentBag.register(componentClass, contracts, getModelEnhancer(componentClass))) {
             processFeatureRegistration(null, componentClass);
@@ -487,7 +494,7 @@ public CommonConfig register(final Object component, final Class<?>... contracts
     }
 
     @Override
-    public CommonConfig register(final Object component, Map<Class<?>, Integer> contracts) {
+    public CommonConfig register(final Object component, final Map<Class<?>, Integer> contracts) {
         checkProviderNotNull(component);
         final Class<?> componentClass = component.getClass();
         if (componentBag.register(component, contracts, getModelEnhancer(componentClass))) {
@@ -497,8 +504,8 @@ public CommonConfig register(final Object component, Map<Class<?>, Integer> cont
         return this;
     }
 
-    private void processFeatureRegistration(Object component, Class<?> componentClass) {
-        ContractProvider model = componentBag.getModel(componentClass);
+    private void processFeatureRegistration(final Object component, final Class<?> componentClass) {
+        final ContractProvider model = componentBag.getModel(componentClass);
         if (model.getContracts().contains(Feature.class)) {
             @SuppressWarnings("unchecked")
             final FeatureRegistration registration = (component != null) ?
@@ -518,7 +525,7 @@ private void processFeatureRegistration(Object component, Class<?> componentClas
      * @param config external configuration state to replace the configuration of this configurable instance.
      * @return the updated common configuration instance.
      */
-    public CommonConfig loadFrom(Configuration config) {
+    public CommonConfig loadFrom(final Configuration config) {
         if (config instanceof CommonConfig) {
             // If loading from CommonConfig then simply copy properties and check whether given config has been initialized.
             final CommonConfig commonConfig = (CommonConfig) config;
@@ -554,19 +561,19 @@ public CommonConfig loadFrom(Configuration config) {
         return this;
     }
 
-    private Set<Class<?>> asNewIdentitySet(Class<?>... contracts) {
-        Set<Class<?>> result = Sets.newIdentityHashSet();
+    private Set<Class<?>> asNewIdentitySet(final Class<?>... contracts) {
+        final Set<Class<?>> result = Sets.newIdentityHashSet();
         result.addAll(Arrays.asList(contracts));
         return result;
     }
 
-    private void checkProviderNotNull(Object provider) {
+    private void checkProviderNotNull(final Object provider) {
         if (provider == null) {
             throw new IllegalArgumentException(LocalizationMessages.COMPONENT_CANNOT_BE_NULL());
         }
     }
 
-    private void checkComponentClassNotNull(Class<?> componentClass) {
+    private void checkComponentClassNotNull(final Class<?> componentClass) {
         if (componentClass == null) {
             throw new IllegalArgumentException(LocalizationMessages.COMPONENT_CLASS_CANNOT_BE_NULL());
         }
@@ -576,17 +583,40 @@ private void checkComponentClassNotNull(Class<?> componentClass) {
      * Configure {@link AutoDiscoverable auto-discoverables} in the HK2 service locator.
      *
      * @param locator locator in which the auto-discoverables should be configured.
+     * @param forcedOnly defines whether all or only forced auto-discoverables should be configured.
      */
-    public void configureAutoDiscoverableProviders(final ServiceLocator locator) {
+    public void configureAutoDiscoverableProviders(final ServiceLocator locator, final boolean forcedOnly) {
         // Check whether meta providers have been initialized for a config this config has been loaded from.
         if (!disableMetaProviderConfiguration) {
-            for (final AutoDiscoverable autoDiscoverable : Providers.getProviders(locator, AutoDiscoverable.class)) {
+            final Set<AutoDiscoverable> providers = new TreeSet<AutoDiscoverable>(new Comparator<AutoDiscoverable>() {
+                @Override
+                public int compare(final AutoDiscoverable o1, final AutoDiscoverable o2) {
+                    final int p1 = o1.getClass().isAnnotationPresent(Priority.class)
+                            ? o1.getClass().getAnnotation(Priority.class).value() : Priorities.USER;
+                    final int p2 = o2.getClass().isAnnotationPresent(Priority.class)
+                            ? o2.getClass().getAnnotation(Priority.class).value() : Priorities.USER;
+
+                    final int compare = Integer.compare(p1, p2);
+                    return compare == 0 ? -1 : compare;
+                }
+            });
+
+            // Forced (always invoked).
+            providers.addAll(Arrays.asList(
+                    ServiceFinder.find(ForcedAutoDiscoverable.class, true).toArray()));
+
+            // Regular.
+            if (!forcedOnly) {
+                providers.addAll(Providers.getProviders(locator, AutoDiscoverable.class));
+            }
+
+            for (final AutoDiscoverable autoDiscoverable : providers) {
                 final ConstrainedTo constrainedTo = autoDiscoverable.getClass().getAnnotation(ConstrainedTo.class);
 
                 if (constrainedTo == null || type.equals(constrainedTo.value())) {
                     try {
                         autoDiscoverable.configure(this);
-                    } catch (Exception e) {
+                    } catch (final Exception e) {
                         LOGGER.log(Level.FINE,
                                 LocalizationMessages.AUTODISCOVERABLE_CONFIGURATION_FAILED(autoDiscoverable.getClass()), e);
                     }
@@ -618,14 +648,14 @@ public void configureMetaProviders(final ServiceLocator locator) {
     }
 
     private Set<Binder> configureBinders(final ServiceLocator locator, final Set<Binder> configured) {
-        Set<Binder> allConfigured = Sets.newIdentityHashSet();
+        final Set<Binder> allConfigured = Sets.newIdentityHashSet();
         allConfigured.addAll(configured);
 
         final Collection<Binder> binders = getBinders(configured);
         if (!binders.isEmpty()) {
             final DynamicConfiguration dc = Injections.getConfiguration(locator);
 
-            for (Binder binder : binders) {
+            for (final Binder binder : binders) {
                 binder.bind(dc);
                 allConfigured.add(binder);
             }
@@ -640,7 +670,7 @@ private Collection<Binder> getBinders(final Set<Binder> configured) {
                 Collections2.transform(componentBag.getInstances(ComponentBag.BINDERS_ONLY), CAST_TO_BINDER),
                 new Predicate<Binder>() {
                     @Override
-                    public boolean apply(Binder binder) {
+                    public boolean apply(final Binder binder) {
                         return !configured.contains(binder);
                     }
                 });
@@ -651,7 +681,7 @@ private void configureFeatures(final ServiceLocator locator,
                                    final List<FeatureRegistration> unprocessed) {
 
         FeatureContextWrapper featureContextWrapper = null;
-        for (FeatureRegistration registration : unprocessed) {
+        for (final FeatureRegistration registration : unprocessed) {
             if (processed.contains(registration)) {
                 LOGGER.config(LocalizationMessages.FEATURE_HAS_ALREADY_BEEN_PROCESSED(registration.getFeatureClass()));
                 continue;
@@ -677,7 +707,7 @@ private void configureFeatures(final ServiceLocator locator,
                 // init lazily
                 featureContextWrapper = new FeatureContextWrapper(this, locator);
             }
-            boolean success = feature.configure(featureContextWrapper);
+            final boolean success = feature.configure(featureContextWrapper);
 
             if (success) {
                 processed.add(registration);
@@ -691,21 +721,21 @@ private void configureFeatures(final ServiceLocator locator,
     }
 
     private List<FeatureRegistration> resetRegistrations() {
-        List<FeatureRegistration> result = new ArrayList<FeatureRegistration>(newFeatureRegistrations);
+        final List<FeatureRegistration> result = new ArrayList<FeatureRegistration>(newFeatureRegistrations);
         newFeatureRegistrations.clear();
         return result;
     }
 
     @Override
-    public boolean equals(Object o) {
+    public boolean equals(final Object o) {
         if (this == o) {
             return true;
         }
         if (!(o instanceof CommonConfig)) {
             return false;
         }
 
-        CommonConfig that = (CommonConfig) o;
+        final CommonConfig that = (CommonConfig) o;
 
         if (type != that.type) {
             return false;

core-server/src/main/java/org/glassfish/jersey/server/ApplicationHandler.java

@@ -380,6 +380,8 @@ private void initialize() {
             if (!CommonProperties.getValue(runtimeConfig.getProperties(), RuntimeType.SERVER,
                     CommonProperties.FEATURE_AUTO_DISCOVERY_DISABLE, Boolean.FALSE, Boolean.class)) {
                 runtimeConfig.configureAutoDiscoverableProviders(locator);
+            } else {
+                runtimeConfig.configureForcedAutoDiscoverableProviders(locator);
             }
 
             // Configure binders and features.

core-server/src/main/java/org/glassfish/jersey/server/ResourceConfig.java

@@ -291,7 +291,7 @@ public State setProperties(Map<String, ?> properties) {
         }
 
         @Override
-        public void configureAutoDiscoverableProviders(final ServiceLocator locator) {
+        public void configureAutoDiscoverableProviders(final ServiceLocator locator, final boolean forcedOnly) {
             throw new IllegalStateException(LocalizationMessages.RC_NOT_MODIFIABLE());
         }
 
@@ -788,7 +788,16 @@ final ComponentBag getComponentBag() {
      * @param locator service locator to obtain auto-discoverables from.
      */
     final void configureAutoDiscoverableProviders(final ServiceLocator locator) {
-        state.configureAutoDiscoverableProviders(locator);
+        state.configureAutoDiscoverableProviders(locator, false);
+    }
+
+    /**
+     * Configure forced auto-discoverables.
+     *
+     * @param locator service locator to obtain auto-discoverables from.
+     */
+    final void configureForcedAutoDiscoverableProviders(final ServiceLocator locator) {
+        state.configureAutoDiscoverableProviders(locator, true);
     }
 
     /**