Temporarily adding back direct support for hk2 binders.

Change-Id: I72f1660e0624b584e48b6cd40671ecb23b8a1790

Author: pavelbucek

core-common/src/main/java/org/glassfish/jersey/hk2/HK2InjectionManager.java

@@ -191,6 +191,11 @@ public void register(Binder binder) {
         Hk2Helper.bind(locator, binder);
     }
 
+    @Override
+    public void register(org.glassfish.hk2.utilities.Binder... binder) {
+        ServiceLocatorUtilities.bind(locator, binder);
+    }
+
     @Override
     public <U> U createAndInitialize(Class<U> clazz) {
         return locator.createAndInitialize(clazz);

core-common/src/main/java/org/glassfish/jersey/hk2/Hk2ReferencingFactory.java

@@ -0,0 +1,136 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2017 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.hk2;
+
+import javax.inject.Provider;
+
+import org.glassfish.jersey.internal.util.collection.Ref;
+import org.glassfish.jersey.internal.util.collection.Refs;
+
+import org.glassfish.hk2.api.Factory;
+
+/**
+ * Factory that provides injection of the referenced instance.
+ *
+ * @param <T>
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public abstract class Hk2ReferencingFactory<T> implements Factory<T> {
+
+    private static class EmptyReferenceFactory<T> implements Factory<Ref<T>> {
+
+        @Override
+        public Ref<T> provide() {
+            return Refs.emptyRef();
+        }
+
+        @Override
+        public void dispose(Ref<T> instance) {
+            //not used
+        }
+    }
+
+    private static class InitializedReferenceFactory<T> implements Factory<Ref<T>> {
+
+        private final T initialValue;
+
+        public InitializedReferenceFactory(T initialValue) {
+            this.initialValue = initialValue;
+        }
+
+        @Override
+        public Ref<T> provide() {
+            return Refs.of(initialValue);
+        }
+
+        @Override
+        public void dispose(Ref<T> instance) {
+            //not used
+        }
+    }
+
+    private final Provider<Ref<T>> referenceFactory;
+
+    /**
+     * Create new referencing injection factory.
+     *
+     * @param referenceFactory reference provider backing the factory.
+     */
+    public Hk2ReferencingFactory(Provider<Ref<T>> referenceFactory) {
+        this.referenceFactory = referenceFactory;
+    }
+
+    @Override
+    public T provide() {
+        return referenceFactory.get().get();
+    }
+
+    @Override
+    public void dispose(T instance) {
+        //not used
+    }
+
+    /**
+     * Get a reference factory providing an empty reference.
+     *
+     * @param <T> reference type.
+     * @return reference factory providing an empty reference.
+     */
+    public static <T> Factory<Ref<T>> referenceFactory() {
+        return new EmptyReferenceFactory<T>();
+    }
+
+    /**
+     * Get a reference factory providing an initialized reference.
+     *
+     * @param <T>          reference type.
+     * @param initialValue initial value stored in the reference provided
+     *                     by the returned factory.
+     * @return reference factory providing a reference initialized with an
+     *         {@code initialValue}.
+     */
+    public static <T> Factory<Ref<T>> referenceFactory(T initialValue) {
+        if (initialValue == null) {
+            return new EmptyReferenceFactory<T>();
+        }
+
+        return new InitializedReferenceFactory<T>(initialValue);
+    }
+}

core-common/src/main/java/org/glassfish/jersey/internal/inject/InjectionManager.java

@@ -112,6 +112,19 @@ public interface InjectionManager {
      */
     void register(Binder binder);
 
+    /**
+     * Register a HK2 Binder.
+     *
+     * For compatibility reasons only, to be removed.
+     *
+     * @param binder collection of descriptors.
+     * @see ClassBinding
+     * @see InstanceBinding
+     * @see SupplierClassBinding
+     * @see SupplierInstanceBinding
+     */
+    void register(org.glassfish.hk2.utilities.Binder... binder);
+
     /**
      * This method creates, injects and post-constructs an object with the given class. This is equivalent to calling the
      * {@code create-class} method followed by the {@code inject-class} method followed by the {@code post-construct} method.

core-common/src/main/java/org/glassfish/jersey/internal/inject/Providers.java

@@ -123,6 +123,7 @@ private static Map<Class<?>, ProviderRuntime> getExternalProviderInterfaces() {
         interfaces.putAll(JAX_RS_PROVIDER_INTERFACE_WHITELIST);
         interfaces.put(javax.ws.rs.core.Feature.class, ProviderRuntime.BOTH);
         interfaces.put(Binder.class, ProviderRuntime.BOTH);
+        interfaces.put(org.glassfish.hk2.utilities.Binder.class, ProviderRuntime.BOTH);
         return interfaces;
     }
 

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

@@ -93,6 +93,8 @@ 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 = Binder.class::cast;
+    private static final Function<Object, org.glassfish.hk2.utilities.Binder> CAST_TO_HK2_BINDER =
+            org.glassfish.hk2.utilities.Binder.class::cast;
 
     /**
      * Configuration runtime type.
@@ -625,7 +627,7 @@ public void configureAutoDiscoverableProviders(final InjectionManager injectionM
      * @param injectionManager locator in which the binders and features should be configured.
      */
     public void configureMetaProviders(InjectionManager injectionManager) {
-        // First, configure existing binders
+        // configure existing binders
         Set<Binder> configuredBinders = configureBinders(injectionManager, Collections.emptySet());
 
         // Check whether meta providers have been initialized for a config this config has been loaded from.
@@ -636,6 +638,19 @@ public void configureMetaProviders(InjectionManager injectionManager) {
             // At last, configure any new binders added by features
             configureBinders(injectionManager, configuredBinders);
         }
+
+        // Configure hk2 binders
+        Set<org.glassfish.hk2.utilities.Binder> configuredHk2Binders =
+                configureHk2Binders(injectionManager, Collections.emptySet());
+
+        // Check whether meta providers have been initialized for a config this config has been loaded from.
+        if (!disableMetaProviderConfiguration) {
+            injectionManager.register(new ManagedObjectsFinalizerHk2Binder());
+            // Next, configure all features
+            configureFeatures(injectionManager, new HashSet<>(), resetRegistrations());
+            // At last, configure any new binders added by features
+            configureHk2Binders(injectionManager, configuredHk2Binders);
+        }
     }
 
     public static class ManagedObjectsFinalizerBinder extends AbstractBinder {
@@ -646,6 +661,14 @@ protected void configure() {
         }
     }
 
+    public static class ManagedObjectsFinalizerHk2Binder extends org.glassfish.hk2.utilities.binding.AbstractBinder {
+        @Override
+        protected void configure() {
+            bindAsContract(ManagedObjectsFinalizer.class)
+                    .in(Singleton.class);
+        }
+    }
+
     private Set<Binder> configureBinders(InjectionManager injectionManager, Set<Binder> configured) {
         Set<Binder> allConfigured = Collections.newSetFromMap(new IdentityHashMap<>());
         allConfigured.addAll(configured);
@@ -659,6 +682,22 @@ private Set<Binder> configureBinders(InjectionManager injectionManager, Set<Bind
         return allConfigured;
     }
 
+    private Set<org.glassfish.hk2.utilities.Binder> configureHk2Binders(
+            InjectionManager injectionManager,
+            Set<org.glassfish.hk2.utilities.Binder> configured) {
+
+        Set<org.glassfish.hk2.utilities.Binder> allConfigured = Collections.newSetFromMap(new IdentityHashMap<>());
+        allConfigured.addAll(configured);
+
+        Collection<org.glassfish.hk2.utilities.Binder> binders = getHk2BeanDescriptors(configured);
+        if (!binders.isEmpty()) {
+            injectionManager.register(binders.toArray(new org.glassfish.hk2.utilities.Binder[]{}));
+            allConfigured.addAll(binders);
+        }
+
+        return allConfigured;
+    }
+
     private Collection<Binder> getBeanDescriptors(Set<Binder> configured) {
         return componentBag.getInstances(ComponentBag.BINDERS_ONLY)
                 .stream()
@@ -667,6 +706,15 @@ private Collection<Binder> getBeanDescriptors(Set<Binder> configured) {
                 .collect(Collectors.toList());
     }
 
+    private Collection<org.glassfish.hk2.utilities.Binder> getHk2BeanDescriptors(
+            Set<org.glassfish.hk2.utilities.Binder> configured) {
+        return componentBag.getInstances(ComponentBag.HK2_BINDERS_ONLY)
+                .stream()
+                .map(CAST_TO_HK2_BINDER)
+                .filter(descriptor -> !configured.contains(descriptor))
+                .collect(Collectors.toList());
+    }
+
     private void configureFeatures(InjectionManager injectionManager,
                                    Set<FeatureRegistration> processed,
                                    List<FeatureRegistration> unprocessed) {

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

@@ -117,6 +117,16 @@ public class ComponentBag {
      */
     public static final Predicate<ContractProvider> BINDERS_ONLY = model -> model.getContracts().contains(Binder.class);
 
+    /**
+     * A filtering strategy that includes only models that contain HK2 Binder provider contract.
+     * <p>
+     * This filter predicate returns {@code true} for all {@link org.glassfish.jersey.model.ContractProvider contract provider models}
+     * that represent a provider registered to provide {@link Binder} contract.
+     * </p>
+     */
+    public static final Predicate<ContractProvider> HK2_BINDERS_ONLY =
+            model -> model.getContracts().contains(org.glassfish.hk2.utilities.Binder.class);
+
     /**
      * A filtering strategy that excludes models with no recognized contracts.
      * <p>