Add HTTP Trace support

Author: jknack

jooby/src/main/java/io/jooby/Route.java

@@ -19,7 +19,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.stream.Stream;
 
 /**
  * Route contains information about the HTTP method, path pattern, which content types consumes and
@@ -307,7 +306,7 @@ public interface Handler extends Serializable {
 
   private static final Map EMPTY_MAP = Collections.emptyMap();
 
-  private Map<String, MessageDecoder> parsers = EMPTY_MAP;
+  private Map<String, MessageDecoder> decoders = EMPTY_MAP;
 
   private final String pattern;
 
@@ -626,7 +625,7 @@ public Route(@Nonnull String method, @Nonnull String pattern, @Nonnull Handler h
    * @return MessageDecoder.
    */
   public @Nonnull MessageDecoder decoder(@Nonnull MediaType contentType) {
-    return parsers.getOrDefault(contentType.getValue(), MessageDecoder.UNSUPPORTED_MEDIA_TYPE);
+    return decoders.getOrDefault(contentType.getValue(), MessageDecoder.UNSUPPORTED_MEDIA_TYPE);
   }
 
   /**
@@ -635,7 +634,7 @@ public Route(@Nonnull String method, @Nonnull String pattern, @Nonnull Handler h
    * @return Message decoders.
    */
   public @Nonnull Map<String, MessageDecoder> getDecoders() {
-    return parsers;
+    return decoders;
   }
 
   /**
@@ -645,30 +644,38 @@ public Route(@Nonnull String method, @Nonnull String pattern, @Nonnull Handler h
    * @return This route.
    */
   public @Nonnull Route setDecoders(@Nonnull Map<String, MessageDecoder> decoders) {
-    this.parsers = decoders;
+    this.decoders = decoders;
     return this;
   }
 
   public boolean isHttpOptions() {
     return supportedMethod != null && supportedMethod.contains(Router.OPTIONS);
   }
 
-  public @Nonnull Route setSupports(String... httpMethods) {
+  public boolean isHttpTrace() {
+    return supportedMethod != null && supportedMethod.contains(Router.TRACE);
+  }
+
+  public @Nonnull Route setHttpOptions(boolean enabled) {
     if (supportedMethod == null) {
       supportedMethod = new HashSet<>();
     }
-    Stream.of(httpMethods).forEach(m -> supportedMethod.add(m.toUpperCase()));
+    if (enabled) {
+      supportedMethod.add(Router.OPTIONS);
+    } else {
+      supportedMethod.remove(Router.OPTIONS);
+    }
     return this;
   }
 
-  public @Nonnull Route setHttpOptions(boolean enabled) {
+  public @Nonnull Route setHttpTrace(boolean enabled) {
     if (supportedMethod == null) {
       supportedMethod = new HashSet<>();
     }
     if (enabled) {
-      supportedMethod.add(Router.OPTIONS);
+      supportedMethod.add(Router.TRACE);
     } else {
-      supportedMethod.remove(Router.OPTIONS);
+      supportedMethod.remove(Router.TRACE);
     }
     return this;
   }

jooby/src/main/java/io/jooby/TraceHandler.java

@@ -0,0 +1,41 @@
+/**
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby;
+
+import javax.annotation.Nonnull;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class TraceHandler implements Route.Decorator {
+  @Nonnull @Override public Route.Handler apply(@Nonnull Route.Handler next) {
+    return ctx -> {
+      if (ctx.getMethod().equals(Router.TRACE)) {
+        // Handle trace
+        String CRLF = "\r\n";
+        StringBuilder buffer = new StringBuilder(Router.TRACE).append(" ").append(ctx.pathString())
+            .append(" ").append(ctx.getProtocol());
+
+        for (Map.Entry<String, List<String>> entry : ctx.headerMultimap().entrySet()) {
+          buffer.append(CRLF).append(entry.getKey()).append(": ")
+              .append(entry.getValue().stream().collect(Collectors.joining(", ")));
+        }
+
+        buffer.append(CRLF);
+
+        ctx.setResponseType("message/http");
+        return ctx.send(buffer.toString());
+      } else {
+        return next.apply(ctx);
+      }
+    };
+  }
+
+  @Nonnull @Override public Route.Decorator setRoute(@Nonnull Route route) {
+    route.setHttpTrace(true);
+    return this;
+  }
+}

jooby/src/main/java/io/jooby/internal/RouterImpl.java

@@ -380,6 +380,8 @@ private Route defineRoute(@Nonnull String method, @Nonnull String pattern,
     tree.insert(route.getMethod(), routePattern, route);
     if (route.isHttpOptions()) {
       tree.insert(Router.OPTIONS, routePattern, route);
+    } else if (route.isHttpTrace()) {
+      tree.insert(Router.TRACE, routePattern, route);
     }
     routes.add(route);
 

tests/src/test/java/io/jooby/FeaturedTest.java

@@ -2701,6 +2701,26 @@ public void options() {
     });
   }
 
+  @Test
+  public void trace() {
+    new JoobyRunner(app -> {
+      app.decorator(new TraceHandler());
+
+      app.get("/foo", Context::pathString);
+    }).ready(client -> {
+      client.trace("/foo", rsp -> {
+        assertEquals(StatusCode.OK.value(), rsp.code());
+        assertEquals("message/http", rsp.header("Content-Type"));
+        assertTrue(rsp.body().string().startsWith("TRACE /foo HTTP/1.1"));
+      });
+
+      client.get("/foo", rsp -> {
+        assertEquals(StatusCode.OK.value(), rsp.code());
+        assertEquals("/foo", rsp.body().string());
+      });
+    });
+  }
+
   private static String readText(Path file) {
     try {
       return new String(Files.readAllBytes(file), StandardCharsets.UTF_8);

tests/src/test/java/io/jooby/WebClient.java

@@ -95,7 +95,13 @@ public void options(String path, SneakyThrows.Consumer<Response> callback) {
     options(path).execute(callback);
   }
 
+  public Request trace(String path) {
+    return invoke("TRACE", path, null);
+  }
 
+  public void trace(String path, SneakyThrows.Consumer<Response> callback) {
+    trace(path).execute(callback);
+  }
 
   public Request post(String path) {
     return post(path, EMPTY_BODY);