Enable @ConstrainedTo on Features

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2019 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -106,23 +106,28 @@ private static final class FeatureRegistration {
 
         private final Class<? extends Feature> featureClass;
         private final Feature feature;
+        private final RuntimeType runtimeType;
 
         private FeatureRegistration(final Class<? extends Feature> featureClass) {
             this.featureClass = featureClass;
             this.feature = null;
+            final ConstrainedTo runtimeTypeConstraint = featureClass.getAnnotation(ConstrainedTo.class);
+            this.runtimeType = runtimeTypeConstraint == null ? null : runtimeTypeConstraint.value();
         }
 
         private FeatureRegistration(final Feature feature) {
             this.featureClass = feature.getClass();
             this.feature = feature;
+            final ConstrainedTo runtimeTypeConstraint = featureClass.getAnnotation(ConstrainedTo.class);
+            this.runtimeType = runtimeTypeConstraint == null ? null : runtimeTypeConstraint.value();
         }
 
         /**
          * Get the registered feature class.
          *
          * @return registered feature class.
          */
-        Class<? extends Feature> getFeatureClass() {
+        private Class<? extends Feature> getFeatureClass() {
             return featureClass;
         }
 
@@ -133,10 +138,21 @@ Class<? extends Feature> getFeatureClass() {
          * @return the registered feature instance or {@code null} if this is a
          *         class based feature registration.
          */
-        public Feature getFeature() {
+        private Feature getFeature() {
             return feature;
         }
 
+        /**
+         * Get the {@code RuntimeType} constraint given by {@code ConstrainedTo} annotated
+         * the Feature or {@code null} if not annotated.
+         *
+         * @return the {@code RuntimeType} constraint given by {@code ConstrainedTo} annotated
+         *         the Feature or {@code null} if not annotated.
+         */
+        private RuntimeType getFeatureRuntimeType() {
+            return runtimeType;
+        }
+
         @Override
         public boolean equals(final Object obj) {
             if (this == obj) {
@@ -674,13 +690,17 @@ private void configureFeatures(InjectionManager injectionManager,
                 // init lazily
                 featureContextWrapper = new FeatureContextWrapper(this, injectionManager);
             }
-            final boolean success = feature.configure(featureContextWrapper);
 
-            if (success) {
-                processed.add(registration);
-                configureFeatures(injectionManager, processed, resetRegistrations(), managedObjectsFinalizer);
-                enabledFeatureClasses.add(registration.getFeatureClass());
-                enabledFeatures.add(feature);
+            final RuntimeType runtimeTypeConstraint = registration.getFeatureRuntimeType();
+            if (runtimeTypeConstraint == null || type.equals(runtimeTypeConstraint)) {
+                final boolean success = feature.configure(featureContextWrapper);
+
+                if (success) {
+                    processed.add(registration);
+                    configureFeatures(injectionManager, processed, resetRegistrations(), managedObjectsFinalizer);
+                    enabledFeatureClasses.add(registration.getFeatureClass());
+                    enabledFeatures.add(feature);
+                }
             }
         }
     }

core-server/src/main/java/org/glassfish/jersey/server/internal/inject/WebTargetValueParamProvider.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2019 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -287,7 +287,7 @@ private void copyProviders(Configuration source, Configurable<?> target) {
         for (Object o : source.getInstances()) {
             Class<?> c = o.getClass();
             if (!targetConfig.isRegistered(o)) {
-                target.register(c, source.getContracts(c));
+                target.register(o, source.getContracts(c));
             }
         }
     }

tests/e2e/src/test/java/org/glassfish/jersey/tests/e2e/common/FeatureConstraintTest.java

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.tests.e2e.common;
+
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.Uri;
+import org.glassfish.jersey.test.JerseyTest;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import javax.ws.rs.ConstrainedTo;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.RuntimeType;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.Feature;
+import javax.ws.rs.core.FeatureContext;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class FeatureConstraintTest extends JerseyTest {
+
+    public static AtomicInteger clientEnvironmentHitCount = new AtomicInteger(0);
+    public static AtomicInteger serverEnvironmentHitCount = new AtomicInteger(0);
+    public static AtomicInteger clientServerEnvironmentHitCount = new AtomicInteger(0);
+
+    @Override
+    protected Application configure() {
+        return new ResourceConfig(PropagatedConfigResource.class, ServerConstrainedClassFeature.class,
+                ClientConstrainedClassFeature.class, ClientServerConstrainedClassFeature.class)
+                .register(new ServerConstrainedInstanceFeature())
+                .register(new ClientConstrainedInstanceFeature())
+                .register(new ClientServerConstrainedInstanceFeature());
+    }
+
+    @ConstrainedTo(RuntimeType.SERVER)
+    public static class ServerConstrainedClassFeature implements Feature {
+        protected int increment = 10;
+        @Override
+        public boolean configure(FeatureContext context) {
+            if (context.getConfiguration().getRuntimeType().equals(RuntimeType.CLIENT)) {
+                clientEnvironmentHitCount.addAndGet(increment);
+            }
+            return true;
+        }
+    }
+
+    @ConstrainedTo(RuntimeType.SERVER)
+    public static class ServerConstrainedInstanceFeature extends ServerConstrainedClassFeature {
+        {
+            increment = 100;
+        }
+    };
+
+    @ConstrainedTo(RuntimeType.CLIENT)
+    public static class ClientConstrainedClassFeature implements Feature {
+        protected int increment = 10;
+        @Override
+        public boolean configure(FeatureContext context) {
+            if (context.getConfiguration().getRuntimeType().equals(RuntimeType.SERVER)) {
+                serverEnvironmentHitCount.addAndGet(increment);
+            }
+            return true;
+        }
+    }
+
+    @ConstrainedTo(RuntimeType.CLIENT)
+    public static class ClientConstrainedInstanceFeature extends ClientConstrainedClassFeature {
+        {
+            increment = 100;
+        }
+    };
+
+    public static class ClientServerConstrainedClassFeature implements Feature {
+        protected int increment = 10;
+        @Override
+        public boolean configure(FeatureContext context) {
+            if (context.getConfiguration().getRuntimeType().equals(RuntimeType.SERVER)) {
+                clientServerEnvironmentHitCount.addAndGet(increment);
+            }
+            if (context.getConfiguration().getRuntimeType().equals(RuntimeType.CLIENT)) {
+                clientServerEnvironmentHitCount.addAndGet(100 * increment);
+            }
+            return true;
+        }
+    }
+
+    public static class ClientServerConstrainedInstanceFeature extends ClientServerConstrainedClassFeature {
+        {
+            increment = 100;
+        }
+    };
+
+    @Path("/")
+    public static class PropagatedConfigResource {
+        @Uri("/isRegistered")
+        WebTarget target;
+
+        @Path("isRegistered")
+        @GET
+        public boolean isRegisteredOnServer(@Context Configuration config) {
+            return config.isRegistered(ServerConstrainedClassFeature.class)
+                    && config.isRegistered(ServerConstrainedInstanceFeature.class)
+                    && config.isRegistered(ClientConstrainedClassFeature.class)
+                    && config.isRegistered(ClientConstrainedInstanceFeature.class)
+                    && config.isRegistered(ClientServerConstrainedClassFeature.class)
+                    && config.isRegistered(ClientServerConstrainedInstanceFeature.class);
+        }
+
+        @Path("isInherited")
+        @GET
+        public boolean isInheritedInInjectedClientConfig() {
+            final Configuration config = target.getConfiguration();
+            return isRegisteredOnServer(config);
+        }
+
+        @Path("featureConfigurationNotInvoked")
+        @GET
+        public boolean featureConfigurationNotInvoked() {
+            return target
+                    .register(ServerConstrainedClassFeature.class)
+                    .register(new ServerConstrainedInstanceFeature())
+                    .register(ClientConstrainedClassFeature.class)
+                    .register(new ClientConstrainedInstanceFeature())
+                    .register(ClientServerConstrainedClassFeature.class)
+                    .register(new ClientServerConstrainedInstanceFeature())
+                    .request().get().readEntity(boolean.class);
+        }
+    }
+
+    @Test
+    public void test() {
+        assertThat("*Constrained*Feature must be registered in a server configuration",
+                target("isRegistered")
+                        .register(ServerConstrainedClassFeature.class)
+                        .register(new ServerConstrainedInstanceFeature())
+                        .register(ClientConstrainedClassFeature.class)
+                        .register(new ClientConstrainedInstanceFeature())
+                        .register(ClientServerConstrainedClassFeature.class)
+                        .register(new ClientServerConstrainedInstanceFeature())
+                        .request().get().readEntity(boolean.class),
+                is(true));
+
+        assertThat("Server Features should not have been configured the Client", clientEnvironmentHitCount.get(), is(0));
+        assertThat("Client Features should not have been configured the Server", serverEnvironmentHitCount.get(), is(0));
+        assertThat("ClientSever Features should have been configured", clientServerEnvironmentHitCount.get(), is(11110));
+        clientServerEnvironmentHitCount.set(0); //reset configuration invoked on a server, it won't happen again
+
+        assertThat("*Constrained*Feature must be in an application classes set",
+                target("isInherited").request().get().readEntity(boolean.class),
+                is(true));
+
+        assertThat("Server Features should not have been configured the Client", clientEnvironmentHitCount.get(), is(0));
+        assertThat("Client Features should not have been configured the Server", serverEnvironmentHitCount.get(), is(0));
+        assertThat("ClientSever Features should not have been configured", clientServerEnvironmentHitCount.get(), is(0));
+
+        assertThat("ServerConstrainedFeature must be in an application classes set",
+                target("featureConfigurationNotInvoked")
+                        .register(ServerConstrainedClassFeature.class)
+                        .register(new ServerConstrainedInstanceFeature())
+                        .register(ClientConstrainedClassFeature.class)
+                        .register(new ClientConstrainedInstanceFeature())
+                        .register(ClientServerConstrainedClassFeature.class)
+                        .register(new ClientServerConstrainedInstanceFeature())
+                        .request().get().readEntity(boolean.class),
+                is(true));
+
+        assertThat("Server Features should not have been configured the Client", clientEnvironmentHitCount.get(), is(0));
+        assertThat("Client Features should not have been configured the Server", serverEnvironmentHitCount.get(), is(0));
+        assertThat("ClientSever Features should have been configured", clientServerEnvironmentHitCount.get(), is(22000));
+    }
+
+
+}