Cookie handling

README.rst

@@ -2,7 +2,7 @@ netty-http
 ==========
 A library to develop HTTP services with `Netty <http://netty.io/>`__. Supports the capability to route end-points based on `JAX-RS <https://jax-rs-spec.java.net/>`__-style annotations. Implements Guava's Service interface to manage the runtime-state of the HTTP service.
 
-Need for this library 
+Need for this library
 ---------------------
 `Netty <http://netty.io/>`__ is a powerful framework to write asynchronous event-driven high-performance applications. While it is relatively easy to write a RESTful HTTP service using netty, the mapping between HTTP routes to handlers is
 not a straight-forward task.
@@ -142,7 +142,7 @@ Example: Sample HTTP service that manages an application lifecycle:
 
   // Setup HTTP service and add Handlers
 
-  // You can either add varargs of HttpHandler or as a list of HttpHanlders as below to the NettyService Builder
+  // You can either add varargs of HttpHandler or as a list of HttpHandlers as below to the NettyService Builder
 
     List<HttpHandler> handlers = new ArrayList<>();
     handlers.add(new PingHandler());
@@ -175,7 +175,7 @@ Code Sample:
                                         .setCertificatePassword("certificatePassword").build())
                              .build();
 
-* Set ``String:certificatePassword`` as "null" when not applicable 
+* Set ``String:certificatePassword`` as "null" when not applicable
 * ``File:keyStore`` points to the key store that holds your SSL certificate
 
 References

src/main/java/io/cdap/http/internal/CookieParser.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright © 2017-2019 Cask Data, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.cdap.http.internal;
+
+import io.netty.handler.codec.http.HttpHeaderNames;
+import io.netty.handler.codec.http.HttpRequest;
+import io.netty.handler.codec.http.cookie.Cookie;
+import io.netty.handler.codec.http.cookie.CookieDecoder;
+import io.netty.handler.codec.http.cookie.ServerCookieDecoder;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Parses cookies from a request.
+ */
+public class CookieParser {
+  private final boolean strict;
+
+  public CookieParser(boolean strict) {
+    this.strict = strict;
+  }
+
+  public Map<String, Cookie> parseCookies(HttpRequest request) {
+    List<String> headers = request.headers().getAll(HttpHeaderNames.COOKIE);
+    if (headers == null || headers.isEmpty()) {
+      return Collections.emptyMap();
+    }
+    ServerCookieDecoder decoder = getCookieDecoder();
+    Map<String, Cookie> cookies = new LinkedHashMap<>();
+    for (String value : headers) {
+      for (Cookie cookie : decoder.decode(value)) {
+        cookies.put(cookie.name(), cookie);
+      }
+    }
+    return cookies;
+  }
+
+  private ServerCookieDecoder getCookieDecoder() {
+    return strict ? ServerCookieDecoder.STRICT : ServerCookieDecoder.LAX;
+  }
+}

src/main/java/io/cdap/http/internal/HttpResourceModel.java

@@ -23,6 +23,8 @@
 import io.netty.handler.codec.http.HttpRequest;
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.QueryStringDecoder;
+import io.netty.handler.codec.http.cookie.Cookie;
+import io.netty.handler.codec.http.cookie.DefaultCookie;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
@@ -36,6 +38,7 @@
 import java.util.Map;
 import java.util.Set;
 import javax.annotation.Nullable;
+import javax.ws.rs.CookieParam;
 import javax.ws.rs.DefaultValue;
 import javax.ws.rs.HeaderParam;
 import javax.ws.rs.PathParam;
@@ -48,7 +51,8 @@
 public final class HttpResourceModel {
 
   private static final Set<Class<? extends Annotation>> SUPPORTED_PARAM_ANNOTATIONS =
-    Collections.unmodifiableSet(new HashSet<>(Arrays.asList(PathParam.class, QueryParam.class, HeaderParam.class)));
+    Collections.unmodifiableSet(new HashSet<>(Arrays.asList(PathParam.class, QueryParam.class, HeaderParam.class,
+        CookieParam.class)));
 
   private final Set<HttpMethod> httpMethods;
   private final String path;
@@ -58,6 +62,7 @@ public final class HttpResourceModel {
   private final ExceptionHandler exceptionHandler;
   private final boolean isSecured;
   private final String[] requiredRoles;
+  private final CookieParser cookieParser = new CookieParser(false);
 
   /**
    * Construct a resource model with HttpMethod, method that handles httprequest, Object that contains the method.
@@ -125,6 +130,8 @@ public HttpMethodInfo handle(HttpRequest request,
       if (httpMethods.contains(request.method())) {
         //Setup args for reflection call
         Object [] args = new Object[paramsInfo.size()];
+        // Parse cookies
+        Map<String, Cookie> cookies = cookieParser.parseCookies(request);
 
         int idx = 0;
         for (Map<Class<? extends Annotation>, ParameterInfo<?>> info : paramsInfo) {
@@ -137,6 +144,9 @@ public HttpMethodInfo handle(HttpRequest request,
           if (info.containsKey(HeaderParam.class)) {
             args[idx] = getHeaderParamValue(info, request);
           }
+          if (info.containsKey(CookieParam.class)) {
+            args[idx] = getCookieParamValue(info, request, cookies);
+          }
           idx++;
         }
 
@@ -195,6 +205,16 @@ private Object getHeaderParamValue(Map<Class<? extends Annotation>, ParameterInf
     return hasHeader ? info.convert(request.headers().getAll(headerName)) : info.convert(defaultValue(annotations));
   }
 
+  @SuppressWarnings("unchecked")
+  private Object getCookieParamValue(Map<Class<? extends Annotation>, ParameterInfo<?>> annotations,
+                                     HttpRequest request, Map<String, Cookie> cookies) throws Exception {
+    ParameterInfo<Cookie> info = (ParameterInfo<Cookie>) annotations.get(CookieParam.class);
+    CookieParam cookieParam = info.getAnnotation();
+    String cookieName = cookieParam.value();
+    boolean hasCookie = cookies.containsKey(cookieName);
+    return hasCookie ? info.convert(cookies.get(cookieName)) : info.convert(defaultCookie(cookieName, annotations));
+  }
+
   /**
    * Returns a List of String created based on the {@link DefaultValue} if it is presented in the annotations Map.
    *
@@ -210,6 +230,19 @@ private List<String> defaultValue(Map<Class<? extends Annotation>, ParameterInfo
     return Collections.singletonList(defaultValue.value());
   }
 
+  /**
+   * Returns a Cookie created based on the {@link DefaultValue} if it is presented in the annotations Map.
+   *
+   * @return a Cookie or null if {@link DefaultValue} is not presented
+   */
+  private Cookie defaultCookie(String name, Map<Class<? extends Annotation>, ParameterInfo<?>> annotations) {
+    List<String> strings = defaultValue(annotations);
+    if (strings == null || strings.isEmpty()) {
+      return null;
+    }
+    return new DefaultCookie(name, strings.get(0));
+  }
+
   /**
    * Gathers all parameters' annotations for the given method, starting from the third parameter.
    */
@@ -239,6 +272,9 @@ private List<Map<Class<? extends Annotation>, ParameterInfo<?>>> createParameter
         } else if (HeaderParam.class.isAssignableFrom(annotationType)) {
           parameterInfo = ParameterInfo.create(annotation,
                                                ParamConvertUtils.createHeaderParamConverter(parameterTypes[i]));
+        } else if (CookieParam.class.isAssignableFrom(annotationType)) {
+          parameterInfo = ParameterInfo.create(annotation,
+                                               ParamConvertUtils.createCookieParamConverter(parameterTypes[i]));
         } else {
           parameterInfo = ParameterInfo.create(annotation, null);
         }

src/main/java/io/cdap/http/internal/ParamConvertUtils.java

@@ -16,6 +16,7 @@
 
 package io.cdap.http.internal;
 
+import io.netty.handler.codec.http.cookie.Cookie;
 import org.apache.commons.beanutils.ConvertUtils;
 
 import java.lang.reflect.Array;
@@ -89,6 +90,37 @@ public static Converter<List<String>, Object> createHeaderParamConverter(Type re
     return createListConverter(resultType);
   }
 
+  /**
+   * Creates a converter function that converts cookie value into an object of the given result type.
+   * Currently, only {@link String} result types are supported.
+   */
+  public static Converter<Cookie, Object> createCookieParamConverter(Type resultType) {
+    Class<?> resultClass = getRawClass(resultType);
+
+    // For string, return the cookie value
+    if (resultClass == String.class) {
+      return new Converter<Cookie, Object>() {
+        @Nullable
+        @Override
+        public Object convert(Cookie from) throws Exception {
+          return from.value();
+        }
+      };
+    }
+    // For cookie objects, convert appropriately.
+    if (resultClass == Cookie.class) {
+      return new Converter<Cookie, Object>() {
+        @Nullable
+        @Override
+        public Object convert(Cookie from) throws Exception {
+          return from;
+        }
+      };
+    }
+
+    throw new IllegalArgumentException("Unsupported CookieParam type " + resultType);
+  }
+
   /**
    * Creates a converter function that converts query parameter into an object of the given result type.
    * It follows the supported types of {@link QueryParam} with the following exceptions:

src/test/java/io/cdap/http/HttpServerTest.java

@@ -42,6 +42,10 @@
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.HttpUtil;
 import io.netty.handler.codec.http.HttpVersion;
+import io.netty.handler.codec.http.cookie.ClientCookieEncoder;
+import io.netty.handler.codec.http.cookie.Cookie;
+import io.netty.handler.codec.http.cookie.DefaultCookie;
+import io.netty.handler.codec.http.cookie.ServerCookieEncoder;
 import io.netty.handler.ssl.SslHandler;
 import io.netty.util.ReferenceCountUtil;
 import io.netty.util.ResourceLeakDetector;
@@ -82,6 +86,7 @@
 import java.util.zip.DeflaterInputStream;
 import java.util.zip.GZIPInputStream;
 import javax.annotation.Nullable;
+import javax.ws.rs.ext.RuntimeDelegate;
 
 /**
  * Test the HttpServer.
@@ -542,7 +547,7 @@ public void testMultiplePathParameters() throws IOException {
 
   //Test the end point where the parameter in path and order of declaration in method signature are different
   @Test
-  public void testMultiplePathParametersWithParamterInDifferentOrder() throws IOException {
+  public void testMultiplePathParametersWithParameterInDifferentOrder() throws IOException {
     HttpURLConnection urlConn = request("/test/v1/message/21/user/sree", HttpMethod.GET);
     Assert.assertEquals(200, urlConn.getResponseCode());
 
@@ -697,6 +702,35 @@ public void testSortedSetQueryParam() throws IOException {
     testContent("/test/v1/sortedSetQueryParam?id=20&id=30&id=20&id=10", expectedContent, HttpMethod.GET);
   }
 
+  @Test
+  public void testStringCookieParam() throws IOException {
+    testContent("/test/v1/stringCookieParam", "ck1:cookie value",
+        new DefaultCookie("ck1", "cookie value"));
+  }
+
+  @Test
+  public void testStringCookieParamDefaultValue() throws IOException {
+    testContent("/test/v1/stringCookieParam", "ck1:def", new Cookie[0]);
+  }
+
+  @Test
+  public void testMultipleStringCookieParam() throws IOException {
+    testContent("/test/v1/multipleStringCookieParam", "ck1:cookie value 1,ck2:cookie value 2",
+        new DefaultCookie("ck1", "cookie value 1"),
+        new DefaultCookie("ck2", "cookie value 2"));
+  }
+
+  @Test
+  public void testNettyCookieCookieParam() throws IOException {
+    testContent("/test/v1/nettyCookieParam", "ck1:cookie value",
+        new DefaultCookie("ck1", "cookie value"));
+  }
+
+  @Test
+  public void testNettyCookieParamDefaultValue() throws IOException {
+    testContent("/test/v1/nettyCookieParam", "ck1:def", new Cookie[0]);
+  }
+
   @Test
   public void testListHeaderParam() throws IOException {
     List<String> names = Arrays.asList("name1", "name3", "name2", "name1");
@@ -972,6 +1006,15 @@ private void testContent(String path, String content, HttpMethod method) throws
     urlConn.disconnect();
   }
 
+  private void testContent(String path, String content, Cookie... cookies) throws IOException {
+    String cookie = ClientCookieEncoder.LAX.encode(cookies);
+    HttpURLConnection urlConn = request(path, HttpMethod.GET);
+    urlConn.addRequestProperty(HttpHeaderNames.COOKIE.toString(), cookie);
+    Assert.assertEquals(200, urlConn.getResponseCode());
+    Assert.assertEquals(content, getContent(urlConn));
+    urlConn.disconnect();
+  }
+
   private HttpURLConnection request(String path, HttpMethod method) throws IOException {
     return request(path, method, false);
   }

src/test/java/io/cdap/http/TestHandler.java

@@ -28,6 +28,8 @@
 import io.netty.handler.codec.http.HttpHeaderValues;
 import io.netty.handler.codec.http.HttpRequest;
 import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.handler.codec.http.cookie.Cookie;
+import io.netty.handler.codec.http.cookie.DefaultCookie;
 import org.junit.Assert;
 
 import java.io.File;
@@ -43,6 +45,7 @@
 import java.util.SortedSet;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.Nullable;
+import javax.ws.rs.CookieParam;
 import javax.ws.rs.DELETE;
 import javax.ws.rs.DefaultValue;
 import javax.ws.rs.GET;
@@ -530,6 +533,27 @@ public void testSortedSetQueryParam(HttpRequest request, HttpResponder responder
     responder.sendString(HttpResponseStatus.OK, GSON.toJson(ids));
   }
 
+  @Path("/stringCookieParam")
+  @GET
+  public void testStringCookieParam(HttpRequest request, HttpResponder responder,
+                                @CookieParam("ck1") @DefaultValue("def") String ck1) {
+    responder.sendString(HttpResponseStatus.OK, "ck1:" + ck1);
+  }
+
+  @Path("/multipleStringCookieParam")
+  @GET
+  public void testMultipleStringCookieParam(HttpRequest request, HttpResponder responder,
+      @CookieParam("ck1") String ck1, @CookieParam("ck2") String ck2) {
+    responder.sendString(HttpResponseStatus.OK, "ck1:" + ck1 + ",ck2:" + ck2);
+  }
+
+  @Path("/nettyCookieParam")
+  @GET
+  public void testNettyCookieParam(HttpRequest request, HttpResponder responder,
+      @CookieParam("ck1") @DefaultValue("def") Cookie ck1) {
+    responder.sendString(HttpResponseStatus.OK, "ck1:" + ck1.value());
+  }
+
   @Path("/listHeaderParam")
   @GET
   public void testListHeaderParam(HttpRequest request, HttpResponder responder,