Check for score overflow

Author: poorna

src/main/java/co/cask/http/HttpResourceHandler.java

@@ -47,8 +47,11 @@
 public final class HttpResourceHandler implements HttpHandler {
 
   private static final Logger LOG = LoggerFactory.getLogger(HttpResourceHandler.class);
+  // Limit the number of parts of the path so that match score calculation during runtime does not overflow
+  private static final int MAX_PATH_PARTS = 25;
 
-  private final PatternPathRouterWithGroups<HttpResourceModel> patternRouter = PatternPathRouterWithGroups.create();
+  private final PatternPathRouterWithGroups<HttpResourceModel> patternRouter =
+    PatternPathRouterWithGroups.create(MAX_PATH_PARTS);
   private final Iterable<HttpHandler> handlers;
   private final Iterable<HandlerHook> handlerHooks;
   private final URLRewriter urlRewriter;
@@ -327,6 +330,11 @@ public HttpMethodInfo getDestinationMethod(HttpRequest request, HttpResponder re
    * @return weighted score
    */
   private long getWeightedMatchScore(Iterable<String> requestUriParts, Iterable<String> destUriParts) {
+    // The score calculated below is a base 5 number
+    // The score will have one digit for one part of the URI
+    // This will allow for 27 parts in the path since log (Long.MAX_VALUE) to base 5 = 27.13
+    // We limit the number of parts in the path to 25 using MAX_PATH_PARTS constant above to avoid overflow during
+    // score calculation
     long score = 0;
     for (Iterator<String> rit = requestUriParts.iterator(), dit = destUriParts.iterator();
          rit.hasNext() && dit.hasNext(); ) {

src/main/java/co/cask/http/PatternPathRouterWithGroups.java

@@ -40,16 +40,18 @@ public final class PatternPathRouterWithGroups<T> {
   // non-greedy wild card match.
   private static final Pattern WILD_CARD_PATTERN = Pattern.compile("\\*\\*");
 
+  private final int maxPathParts;
   private final List<ImmutablePair<Pattern, RouteDestinationWithGroups>> patternRouteList;
 
-  public static <T> PatternPathRouterWithGroups<T> create() {
-    return new PatternPathRouterWithGroups<>();
+  public static <T> PatternPathRouterWithGroups<T> create(int maxPathParts) {
+    return new PatternPathRouterWithGroups<>(maxPathParts);
   }
 
   /**
    * Initialize PatternPathRouterWithGroups.
    */
-  public PatternPathRouterWithGroups() {
+  public PatternPathRouterWithGroups(int maxPathParts) {
+    this.maxPathParts = maxPathParts;
     this.patternRouteList = Lists.newArrayList();
   }
 
@@ -69,6 +71,10 @@ public void add(final String source, final T destination) {
 
 
     String [] parts = path.split("/");
+    if (parts.length - 1 > maxPathParts) {
+      throw new IllegalArgumentException(String.format("Number of parts of path %s exceeds allowed limit %s",
+                                                       source, maxPathParts));
+    }
     StringBuilder sb =  new StringBuilder();
     List<String> groupNames = Lists.newArrayList();
 

src/test/java/co/cask/http/PathRouterTest.java

@@ -31,7 +31,7 @@ public class PathRouterTest {
   @Test
   public void testPathRoutings() {
 
-    PatternPathRouterWithGroups<String> pathRouter = PatternPathRouterWithGroups.create();
+    PatternPathRouterWithGroups<String> pathRouter = PatternPathRouterWithGroups.create(25);
     pathRouter.add("/foo/{baz}/b", "foobarb");
     pathRouter.add("/foo/bar/baz", "foobarbaz");
     pathRouter.add("/baz/bar", "bazbar");
@@ -167,4 +167,10 @@ public void testPathRoutings() {
     Assert.assertEquals("wildcard-foo-id-2", routes.get(0).getDestination());
     Assert.assertEquals(ImmutableMap.of("id", "id1"), routes.get(0).getGroupNameValues());
   }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testMaxPathParts() throws Exception {
+    PatternPathRouterWithGroups<String> pathRouter = PatternPathRouterWithGroups.create(5);
+    pathRouter.add("/1/2/3/4/5/6", "max-path-parts");
+  }
 }