Added shortcut methods for registering MediaSupport on WebServer.Builder (helidon-io#6564)

Author: tomas-langer

nima/http/media/media/src/main/java/io/helidon/nima/http/media/MediaContext.java

@@ -18,6 +18,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.ServiceLoader;
 
 import io.helidon.common.GenericType;
@@ -115,6 +116,7 @@ class Builder implements io.helidon.common.Builder<Builder, MediaContext> {
         private final HelidonServiceLoader.Builder<MediaSupportProvider> mediaSupportProviders;
         private final List<MediaSupport> explicitSupports = new ArrayList<>();
         private Config providersConfig;
+        private MediaContext fallback;
 
         // Builder instance must be created using factory method.
         private Builder() {
@@ -141,7 +143,7 @@ public MediaContext build() {
             supports.add(StringSupport.create());
             supports.add(PathSupport.create());
             supports.add(FormParamsSupport.create());
-            return new MediaContextImpl(supports);
+            return new MediaContextImpl(supports, fallback);
         }
 
         /**
@@ -183,6 +185,18 @@ public Builder addMediaSupport(MediaSupport mediaSupport) {
             explicitSupports.add(mediaSupport);
             return this;
         }
+
+        /**
+         * Configure an existing context as a fallback for this context.
+         *
+         * @param mediaContext media context to use if supports configured on this request cannot provide a good result
+         * @return updated builder
+         */
+        public Builder fallback(MediaContext mediaContext) {
+            Objects.requireNonNull(mediaContext);
+            this.fallback = mediaContext;
+            return this;
+        }
     }
 
 }

nima/http/media/media/src/main/java/io/helidon/nima/http/media/MediaContextImpl.java

@@ -40,10 +40,12 @@ class MediaContextImpl implements MediaContext {
     private static final ConcurrentHashMap<GenericType<?>, AtomicBoolean> LOGGED_WRITERS = new ConcurrentHashMap<>();
 
     private final List<MediaSupport> supports;
+    private final MediaContext fallback;
 
-    MediaContextImpl(List<MediaSupport> supports) {
+    MediaContextImpl(List<MediaSupport> supports, MediaContext fallback) {
         this.supports = supports;
         this.supports.forEach(it -> it.init(this));
+        this.fallback = fallback;
     }
 
     @Override
@@ -58,7 +60,11 @@ public <T> EntityReader<T> reader(GenericType<T> type, Headers headers) {
             }
         }
         if (compatible == null) {
-            return FailingReader.instance();
+            if (fallback == null) {
+                return FailingReader.instance();
+            } else {
+                return fallback.reader(type, headers);
+            }
         }
         return entityReader(compatible);
     }
@@ -79,7 +85,11 @@ public <T> EntityWriter<T> writer(GenericType<T> type,
         }
 
         if (compatible == null) {
-            return FailingWriter.instance();
+            if (fallback == null) {
+                return FailingWriter.instance();
+            } else {
+                return fallback.writer(type, requestHeaders, responseHeaders);
+            }
         }
         return entityWriter(compatible);
     }
@@ -100,7 +110,11 @@ public <T> EntityReader<T> reader(GenericType<T> type,
             }
         }
         if (compatible == null) {
-            return FailingReader.instance();
+            if (fallback == null) {
+                return FailingReader.instance();
+            } else {
+                return fallback.reader(type, requestHeaders, responseHeaders);
+            }
         }
         return entityReader(compatible);
     }
@@ -119,7 +133,11 @@ public <T> EntityWriter<T> writer(GenericType<T> type, WritableHeaders<?> reques
         }
 
         if (compatible == null) {
-            return FailingWriter.instance();
+            if (fallback == null) {
+                return FailingWriter.instance();
+            } else {
+                return fallback.writer(type, requestHeaders);
+            }
         }
         return entityWriter(compatible);
     }

nima/webserver/webserver/src/main/java/io/helidon/nima/webserver/WebServer.java

@@ -34,6 +34,7 @@
 import io.helidon.nima.common.tls.Tls;
 import io.helidon.nima.http.encoding.ContentEncodingContext;
 import io.helidon.nima.http.media.MediaContext;
+import io.helidon.nima.http.media.MediaSupport;
 import io.helidon.nima.webserver.http.DirectHandlers;
 import io.helidon.nima.webserver.http.HttpRouting;
 import io.helidon.nima.webserver.spi.ServerConnectionProvider;
@@ -170,8 +171,8 @@ class Builder implements io.helidon.common.Builder<Builder, WebServer>, Router.R
         private final DefaultServerConfig.Builder configBuilder = DefaultServerConfig.builder();
 
         private Config providersConfig = Config.empty();
-        // MediaContext should be updated with config processing or during final build if not set.
-        private MediaContext mediaContext;
+        private MediaContext mediaContext = MediaContext.create();
+        private MediaContext.Builder mediaContextBuilder;
         private ContentEncodingContext contentEncodingContext = ContentEncodingContext.create();
 
         private boolean shutdownHook = true;
@@ -198,8 +199,17 @@ public WebServer build() {
                         .build();
             }
             if (mediaContext == null) {
-                mediaContext(MediaContext.create());
+                if (mediaContextBuilder == null) {
+                    mediaContext = MediaContext.create();
+                } else {
+                    mediaContext = mediaContextBuilder.build();
+                }
+            } else {
+                if (mediaContextBuilder != null) {
+                    mediaContext = mediaContextBuilder.fallback(mediaContext).build();
+                }
             }
+            mediaContextBuilder = null;
 
             return new LoomServer(this, configBuilder.build(), directHandlers.build());
         }
@@ -264,10 +274,15 @@ public Builder config(Config config) {
                     .as(ContentEncodingContext::create)
                     .ifPresent(this::contentEncodingContext);
             // Configure media support
-            config.get("media-support")
-                    .as(MediaContext::create)
-                    // MediaContext always needs to be refreshed after config change
-                    .ifPresent(this::mediaContext);
+            Config mediaSupportConfig = config.get("media-support");
+            if (mediaSupportConfig.exists()) {
+                // we are directly updating the builder, and we do not need to fallback to defaults
+                // also configuration overrides any manual setup
+                mediaContext = null;
+                mediaContextBuilder = MediaContext.builder();
+                mediaSupportConfig.ifExists(mediaContextBuilder::config);
+            }
+
             // Store providers config node for later usage.
             providersConfig = config.get("connection-providers");
             return this;
@@ -424,11 +439,35 @@ public boolean hasSocket(String socketName) {
         }
 
         /**
-         * Configure the default {@link MediaContext}.
-         * This method discards all previously registered MediaContext.
+         * Add an explicit media support to the list.
+         * By default, all discovered media supports will be available to the server. Use this method only when
+         * the media support is not discoverable by service loader, or when using explicit
+         * {@link #mediaContext(io.helidon.nima.http.media.MediaContext)}.
+         *
+         * @param mediaSupport media support to add
+         * @return updated builder
+         */
+        public Builder addMediaSupport(MediaSupport mediaSupport) {
+            Objects.requireNonNull(mediaSupport);
+            if (mediaContextBuilder == null) {
+                mediaContextBuilder = MediaContext.builder()
+                        .discoverServices(false);
+            }
+
+            mediaContextBuilder.addMediaSupport(mediaSupport);
+            return this;
+        }
+
+        /**
+         * Configure the {@link MediaContext}.
+         * This method discards previously registered {@link io.helidon.nima.http.media.MediaContext}
+         * and all previously registered {@link io.helidon.nima.http.media.MediaSupport}.
+         * If an explicit media support is configured using {@link #addMediaSupport(io.helidon.nima.http.media.MediaSupport)},
+         * this context will be used as a fallback for a new one created from configured values.
          *
          * @param mediaContext media context
          * @return updated instance of the builder
+         * @see #addMediaSupport(io.helidon.nima.http.media.MediaSupport)
          */
         public Builder mediaContext(MediaContext mediaContext) {
             Objects.requireNonNull(mediaContext);

nima/webserver/webserver/src/test/java/io/helidon/nima/webserver/WebServerConfigTest.java

@@ -92,6 +92,7 @@ void testMediaSupportFileConfigJson() throws IOException {
         Config config = Config.create();
         Config server = config.get("server2");
         WebServer.Builder wsBuilder = WebServer.builder().config(server);
+        wsBuilder.build(); // triggers processing of media context
         MediaContext mediaContext = wsBuilder.mediaContext();
         assertThat(mediaContext, is(notNullValue()));
         WritableHeaders<?> writableHeaders = WritableHeaders.create();
@@ -120,6 +121,7 @@ void testMediaSupportFileConfigJson() throws IOException {
     void testMediaSupportFileConfigNoJson() throws IOException {
         Config config = Config.create();
         WebServer.Builder wsBuilder = WebServer.builder().config(config.get("server"));
+        wsBuilder.build(); // trigger processing of media context
         MediaContext mediaContext = wsBuilder.mediaContext();
         assertThat(mediaContext, is(notNullValue()));
         WritableHeaders<?> writableHeaders = WritableHeaders.create();