Media support methods (helidon-io#1905)

* Get method removed from MessageBodyOperators
* JSON-P support changed
* JSON-B support changed
* Jackson support changed
* Default support builder added

Signed-off-by: David Kral <david.k.kral@oracle.com>

Author: Verdent

health/health/src/main/java/io/helidon/health/HealthSupport.java

@@ -35,14 +35,15 @@
 import javax.json.JsonBuilderFactory;
 import javax.json.JsonObject;
 import javax.json.JsonObjectBuilder;
+import javax.json.JsonStructure;
 
 import io.helidon.common.GenericType;
 import io.helidon.common.HelidonFeatures;
 import io.helidon.common.HelidonFlavor;
 import io.helidon.common.http.Http;
 import io.helidon.common.reactive.Single;
 import io.helidon.config.Config;
-import io.helidon.media.jsonp.JsonpBodyWriter;
+import io.helidon.media.common.MessageBodyWriter;
 import io.helidon.media.jsonp.JsonpSupport;
 import io.helidon.webserver.Routing;
 import io.helidon.webserver.ServerRequest;
@@ -88,7 +89,7 @@ public final class HealthSupport implements Service {
     private final Set<String> excludedHealthChecks;
     private final boolean backwardCompatible;
     private final CorsEnabledServiceHelper corsEnabledServiceHelper;
-    private final JsonpBodyWriter jsonpWriter = JsonpSupport.writer();
+    private final MessageBodyWriter<JsonStructure> jsonpWriter = JsonpSupport.writer();
 
     private HealthSupport(Builder builder) {
         this.enabled = builder.enabled;

media/common/src/main/java/io/helidon/media/common/ByteChannelBodyWriter.java

@@ -28,10 +28,12 @@
 /**
  * Message body writer for {@link ReadableByteChannel}.
  */
-public final class ByteChannelBodyWriter implements MessageBodyWriter<ReadableByteChannel> {
+final class ByteChannelBodyWriter implements MessageBodyWriter<ReadableByteChannel> {
 
     static final RetrySchema DEFAULT_RETRY_SCHEMA = RetrySchema.linear(0, 10, 250);
 
+    private static final ByteChannelBodyWriter DEFAULT = new ByteChannelBodyWriter(DEFAULT_RETRY_SCHEMA);
+
     private final ByteChannelToChunks mapper;
 
     /**
@@ -62,20 +64,21 @@ public Publisher<DataChunk> write(Single<? extends ReadableByteChannel> content,
      * @param schema retry schema
      * @return {@link ReadableByteChannel} message body writer
      */
-    public static ByteChannelBodyWriter create(RetrySchema schema) {
+    static ByteChannelBodyWriter create(RetrySchema schema) {
         return new ByteChannelBodyWriter(schema);
     }
 
     /**
-     * Create a new instance of {@link ByteChannelBodyWriter}.
+     * Return an instance of {@link ByteChannelBodyWriter}.
+     *
      * @return {@link ReadableByteChannel} message body writer
      */
-    public static ByteChannelBodyWriter create() {
-        return new ByteChannelBodyWriter(DEFAULT_RETRY_SCHEMA);
+    static ByteChannelBodyWriter create() {
+        return DEFAULT;
     }
 
     /**
-     * Implementation of {@link MultiMapper} that converts a
+     * Implementation of {@link Mapper} that converts a
      * {@link ReadableByteChannel} to a publisher of {@link DataChunk}.
      */
     private static final class ByteChannelToChunks implements Mapper<ReadableByteChannel, Publisher<DataChunk>> {

media/common/src/main/java/io/helidon/media/common/CharSequenceBodyWriter.java

@@ -27,7 +27,9 @@
 /**
  * Writer for {@code CharSequence}.
  */
-public final class CharSequenceBodyWriter implements MessageBodyWriter<CharSequence> {
+final class CharSequenceBodyWriter implements MessageBodyWriter<CharSequence> {
+
+    private static final CharSequenceBodyWriter DEFAULT = new CharSequenceBodyWriter();
 
     /**
      * Enforce the use of {@link #create()}.
@@ -50,11 +52,12 @@ public Publisher<DataChunk> write(Single<? extends CharSequence> content,
     }
 
     /**
-     * Create a new instance of {@link CharSequenceBodyWriter}.
+     * Return an instance of {@link CharSequenceBodyWriter}.
+     *
      * @return {@link CharSequence} message body writer.
      */
-    public static CharSequenceBodyWriter create() {
-        return new CharSequenceBodyWriter();
+    static CharSequenceBodyWriter create() {
+        return DEFAULT;
     }
 
     private static final class CharSequenceToChunks implements Mapper<CharSequence, Publisher<DataChunk>> {

media/common/src/main/java/io/helidon/media/common/ContentReaders.java

@@ -120,7 +120,9 @@ public static Reader<byte[]> byteArrayReader() {
      * {@link InputStream#read()}) block.
      *
      * @return a input stream content reader
+     * @deprecated use {@link DefaultMediaSupport#inputStreamReader()}
      */
+    @Deprecated(since = "2.0.0")
     public static Reader<InputStream> inputStreamReader() {
         return (publisher, clazz) -> CompletableFuture.completedFuture(new DataChunkInputStream(publisher));
     }

media/common/src/main/java/io/helidon/media/common/DefaultMediaSupport.java

@@ -15,42 +15,195 @@
  */
 package io.helidon.media.common;
 
+import java.io.File;
+import java.io.InputStream;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.file.Path;
 import java.util.Collection;
 import java.util.List;
+import java.util.Objects;
+
+import io.helidon.common.reactive.RetrySchema;
+import io.helidon.config.Config;
 
 /**
  * MediaSupport which registers default readers and writers to the contexts.
  */
 public class DefaultMediaSupport implements MediaSupport {
 
-    private final boolean includeStackTraces;
+    private final ByteChannelBodyWriter byteChannelBodyWriter;
+    private final ThrowableBodyWriter throwableBodyWriter;
 
-    private DefaultMediaSupport(boolean includeStackTraces) {
-        this.includeStackTraces = includeStackTraces;
+    private DefaultMediaSupport(Builder builder) {
+        byteChannelBodyWriter = ByteChannelBodyWriter.create(builder.schema);
+        throwableBodyWriter = ThrowableBodyWriter.create(builder.includeStackTraces);
     }
 
     /**
      * Creates new instance of {@link DefaultMediaSupport}.
      *
-     * @param includeStackTraces include stack traces
      * @return new service instance
      */
-    public static DefaultMediaSupport create(boolean includeStackTraces) {
-        return new DefaultMediaSupport(includeStackTraces);
+    public static DefaultMediaSupport create() {
+        return builder().build();
+    }
+
+    /**
+     * Return new {@link Builder} of the {@link DefaultMediaSupport}.
+     *
+     * @return default media support builder
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Return {@link String} reader instance.
+     *
+     * @return {@link String} reader
+     */
+    public static MessageBodyReader<String> stringReader() {
+        return StringBodyReader.create();
+    }
+
+    /**
+     * Return {@link InputStream} reader instance.
+     *
+     * @return {@link InputStream} reader
+     */
+    public static MessageBodyReader<InputStream> inputStreamReader() {
+        return InputStreamBodyReader.create();
+    }
+
+    /**
+     * Return {@link CharSequence} writer instance.
+     *
+     * @return {@link CharSequence} writer
+     */
+    public static MessageBodyWriter<CharSequence> charSequenceWriter() {
+        return CharSequenceBodyWriter.create();
+    }
+
+    /**
+     * Create a new instance of {@link ReadableByteChannel} writer.
+     *
+     * @return {@link ReadableByteChannel} writer
+     */
+    public static MessageBodyWriter<ReadableByteChannel> byteChannelWriter() {
+        return ByteChannelBodyWriter.create();
+    }
+
+    /**
+     * Return new {@link ReadableByteChannel} writer instance with specific {@link RetrySchema}.
+     *
+     * @param schema retry schema
+     * @return {@link ReadableByteChannel} writer
+     */
+    public static MessageBodyWriter<ReadableByteChannel> byteChannelWriter(RetrySchema schema) {
+        return ByteChannelBodyWriter.create(schema);
+    }
+
+    /**
+     * Return {@link Path} writer instance.
+     *
+     * @return {@link Path} writer
+     */
+    public static MessageBodyWriter<Path> pathWriter() {
+        return PathBodyWriter.create();
+    }
+
+    /**
+     * Return {@link File} writer instance.
+     *
+     * @return {@link File} writer
+     */
+    public static MessageBodyWriter<File> fileWriter() {
+        return FileBodyWriter.create();
+    }
+
+    /**
+     * Return {@link Throwable} writer instance.
+     *
+     * @param includeStackTraces whether stack traces are to be written
+     * @return {@link Throwable} writer
+     */
+    public static MessageBodyWriter<Throwable> throwableWriter(boolean includeStackTraces) {
+        return ThrowableBodyWriter.create(includeStackTraces);
     }
 
     @Override
     public Collection<MessageBodyReader<?>> readers() {
-        return List.of(StringBodyReader.create(),
-                       InputStreamBodyReader.create());
+        return List.of(stringReader(),
+                       inputStreamReader());
     }
 
     @Override
     public Collection<MessageBodyWriter<?>> writers() {
-        return List.of(CharSequenceBodyWriter.create(),
-                       ByteChannelBodyWriter.create(),
-                       PathBodyWriter.create(),
-                       FileBodyWriter.create(),
-                       ThrowableBodyWriter.create(includeStackTraces));
+        return List.of(charSequenceWriter(),
+                       byteChannelBodyWriter,
+                       pathWriter(),
+                       fileWriter(),
+                       throwableBodyWriter);
+    }
+
+    /**
+     * Default media support builder.
+     */
+    public static class Builder implements io.helidon.common.Builder<DefaultMediaSupport> {
+
+        private boolean includeStackTraces = false;
+        private RetrySchema schema = ByteChannelBodyWriter.DEFAULT_RETRY_SCHEMA;
+
+        private Builder() {
+        }
+
+        @Override
+        public DefaultMediaSupport build() {
+            return new DefaultMediaSupport(this);
+        }
+
+        /**
+         * Whether stack traces should be included in response.
+         *
+         * @param includeStackTraces include stack trace
+         * @return updated builder instance
+         */
+        public Builder includeStackTraces(boolean includeStackTraces) {
+            this.includeStackTraces = includeStackTraces;
+            return this;
+        }
+
+        /**
+         * Set specific {@link RetrySchema} to the byte channel.
+         *
+         * @param schema retry schema
+         * @return updated builder instance
+         */
+        public Builder byteChannelRetrySchema(RetrySchema schema) {
+            this.schema = Objects.requireNonNull(schema);
+            return this;
+        }
+
+        /**
+         * Configures this {@link DefaultMediaSupport.Builder} from the supplied {@link Config}.
+         * <table class="config">
+         * <caption>Optional configuration parameters</caption>
+         * <tr>
+         *     <th>key</th>
+         *     <th>description</th>
+         * </tr>
+         * <tr>
+         *     <td>include-stack-traces</td>
+         *     <td>Whether stack traces should be included in response</td>
+         * </tr>
+         * </table>
+         *
+         * @param config media support config
+         * @return updated builder instance
+         */
+        public Builder config(Config config) {
+            config.get("include-stack-traces").asBoolean().ifPresent(this::includeStackTraces);
+            return this;
+        }
     }
 }

media/common/src/main/java/io/helidon/media/common/FileBodyWriter.java

@@ -35,7 +35,9 @@
 /**
  * Message body writer for {@link File}.
  */
-public final class FileBodyWriter implements MessageBodyWriter<File> {
+final class FileBodyWriter implements MessageBodyWriter<File> {
+
+    private static final FileBodyWriter DEFAULT = new FileBodyWriter();
 
     /**
      * Enforces the use of {@link #create()}.
@@ -56,11 +58,12 @@ public Publisher<DataChunk> write(Single<? extends File> content,
     }
 
     /**
-     * Create a new {@link FileBodyWriter} instance.
+     * Return an instance of {@link FileBodyWriter}.
+     *
      * @return {@link File} message body writer.
      */
-    public static FileBodyWriter create() {
-        return new FileBodyWriter();
+    static FileBodyWriter create() {
+        return DEFAULT;
     }
 
     /**

media/common/src/main/java/io/helidon/media/common/InputStreamBodyReader.java

@@ -25,7 +25,9 @@
 /**
  * Message body reader for {@link InputStream}.
  */
-public class InputStreamBodyReader implements MessageBodyReader<InputStream> {
+class InputStreamBodyReader implements MessageBodyReader<InputStream> {
+
+    private static final InputStreamBodyReader DEFAULT = new InputStreamBodyReader();
 
     /**
      * Enforce the use of {@link #create()}.
@@ -35,7 +37,11 @@ private InputStreamBodyReader() {
 
     @Override
     public PredicateResult accept(GenericType<?> type, MessageBodyReaderContext context) {
-        return PredicateResult.supports(InputStream.class, type);
+        if (InputStream.class.equals(type.rawType())
+                || DataChunkInputStream.class.equals(type.rawType())) {
+            return PredicateResult.SUPPORTED;
+        }
+        return PredicateResult.NOT_SUPPORTED;
     }
 
     @Override
@@ -47,10 +53,11 @@ public <U extends InputStream> Single<U> read(Publisher<DataChunk> publisher, Ge
     }
 
     /**
-     * Create a new instance of {@link InputStreamBodyReader}.
+     * Return an instance of {@link InputStreamBodyReader}.
+     *
      * @return {@link InputStream} message body reader.
      */
-    public static InputStreamBodyReader create() {
-        return new InputStreamBodyReader();
+    static InputStreamBodyReader create() {
+        return DEFAULT;
     }
 }