Support for external configuration mechanics (Microprofile Config)

Author: mkarg

bundles/jaxrs-ri/pom.xml

@@ -191,6 +191,12 @@
             <artifactId>persistence-api</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.eclipse.microprofile.config</groupId>
+            <artifactId>microprofile-config-api</artifactId>
+	    <version>${microprofile.config.version}</version>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 
     <build>

core-server/pom.xml

@@ -227,6 +227,13 @@
             <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
+
+        <dependency>
+            <groupId>org.eclipse.microprofile.config</groupId>
+            <artifactId>microprofile-config-api</artifactId>
+            <version>${microprofile.config.version}</version>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 
     <profiles>

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

@@ -33,6 +33,7 @@
 import javax.ws.rs.JAXRS.Configuration.SSLClientAuthentication;
 import javax.ws.rs.core.Application;
 
+import org.eclipse.microprofile.config.Config;
 import org.glassfish.jersey.internal.AbstractRuntimeDelegate;
 import org.glassfish.jersey.message.internal.MessagingBinders;
 import org.glassfish.jersey.server.ContainerFactory;
@@ -116,6 +117,19 @@ public final <T> Builder from(final BiFunction<String, Class<T>, Optional<T>> co
                 return this;
             }
 
+            @Override
+            public final Builder from(final Object externalConfig) {
+                if (externalConfig instanceof Config) {
+                    return this.from((Config) externalConfig);
+                }
+
+                return this;
+            }
+
+            private final Builder from(final Config config) {
+                return this.from(config::getOptionalValue);
+            }
+
             @Override
             public final JAXRS.Configuration build() {
                 return this.properties::get;

core-server/src/test/java/org/glassfish/jersey/server/internal/RuntimeDelegateImplTest.java

@@ -41,6 +41,8 @@
 import javax.ws.rs.core.Application;
 import javax.ws.rs.ext.RuntimeDelegate;
 
+import org.eclipse.microprofile.config.Config;
+import org.eclipse.microprofile.config.spi.ConfigSource;
 import org.glassfish.jersey.internal.ServiceFinder;
 import org.glassfish.jersey.internal.ServiceFinder.ServiceIteratorProvider;
 import org.glassfish.jersey.server.ApplicationHandler;
@@ -228,6 +230,75 @@ public final void shouldBuildCustomConfigurationFromPropertiesProvider() {
         assertThat(configuration.property(ServerProperties.AUTO_START), is(FALSE));
     }
 
+    @Test
+    public final void shouldBuildCustomConfigurationFromMicroprofileConfig() {
+        // given
+        final JAXRS.Configuration.Builder configurationBuilder = new RuntimeDelegateImpl().createConfigurationBuilder();
+        final SSLContext mockSslContext = new SSLContext(null, null, null) {
+        };
+        final Class<Server> mockServerClass = Server.class;
+        final Config config = new Config() {
+            @Override
+            public final <T> T getValue(final String propertyName, final Class<T> propertyType) {
+                return null;
+            }
+
+            @Override
+            public final <T> Optional<T> getOptionalValue(final String propertyName, final Class<T> propertyType) {
+                if (JAXRS.Configuration.PROTOCOL.equals(propertyName) && String.class.equals(propertyType)) {
+                    return Optional.of(propertyType.cast("HTTPS"));
+                }
+                if (JAXRS.Configuration.HOST.equals(propertyName) && String.class.equals(propertyType)) {
+                    return Optional.of(propertyType.cast("hostname"));
+                }
+                if (JAXRS.Configuration.PORT.equals(propertyName) && Integer.class.equals(propertyType)) {
+                    return Optional.of(propertyType.cast(8080));
+                }
+                if (JAXRS.Configuration.ROOT_PATH.equals(propertyName) && String.class.equals(propertyType)) {
+                    return Optional.of(propertyType.cast("path"));
+                }
+                if (JAXRS.Configuration.SSL_CLIENT_AUTHENTICATION.equals(propertyName)
+                        && JAXRS.Configuration.SSLClientAuthentication.class.equals(propertyType)) {
+                    return Optional.of(propertyType.cast(JAXRS.Configuration.SSLClientAuthentication.OPTIONAL));
+                }
+                if (JAXRS.Configuration.SSL_CONTEXT.equals(propertyName) && SSLContext.class.equals(propertyType)) {
+                    return Optional.of(propertyType.cast(mockSslContext));
+                }
+                if (ServerProperties.HTTP_SERVER_CLASS.equals(propertyName) && Class.class.equals(propertyType)) {
+                    return Optional.of(propertyType.cast(mockServerClass));
+                }
+                if (ServerProperties.AUTO_START.equals(propertyName) && Boolean.class.equals(propertyType)) {
+                    return Optional.of(propertyType.cast(FALSE));
+                }
+                return Optional.empty();
+            }
+
+            @Override
+            public final Iterable<String> getPropertyNames() {
+                return null;
+            }
+
+            @Override
+            public final Iterable<ConfigSource> getConfigSources() {
+                return null;
+            }
+        };
+
+        // when
+        final JAXRS.Configuration configuration = configurationBuilder.from(config).build();
+
+        // then
+        assertThat(configuration, is(notNullValue()));
+        assertThat(configuration.protocol(), is("HTTPS"));
+        assertThat(configuration.host(), is("hostname"));
+        assertThat(configuration.port(), is(8080));
+        assertThat(configuration.rootPath(), is("path"));
+        assertThat(configuration.sslClientAuthentication(), is(JAXRS.Configuration.SSLClientAuthentication.OPTIONAL));
+        assertThat(configuration.sslContext(), is(theInstance(mockSslContext)));
+        assertThat(configuration.property(ServerProperties.HTTP_SERVER_CLASS), is(theInstance(mockServerClass)));
+        assertThat(configuration.property(ServerProperties.AUTO_START), is(FALSE));
+    }
+
     @Test
     public final void shouldBootstrapApplication() throws InterruptedException, ExecutionException, TimeoutException {
         // given

pom.xml

@@ -2010,5 +2010,6 @@
         <xmlunit.version>1.6</xmlunit.version>
         <yasson.version>1.0.1</yasson.version>
         <skip.e2e>false</skip.e2e>
+        <microprofile.config.version>1.3</microprofile.config.version>
     </properties>
 </project>