Supporting multiple HTTP route groups per HTTP server setup.

rapidoid-http-fast/src/main/java/org/rapidoid/http/FastHttp.java

@@ -51,28 +51,18 @@ public class FastHttp extends AbstractHttpProcessor {
 
 	private static final HttpParser HTTP_PARSER = new HttpParser();
 
-	private final HttpRoutesImpl routes;
+	private final HttpRoutesImpl[] routes;
 	private final Customization customization;
 
 	private final Map<String, Object> attributes = Coll.synchronizedMap();
 	private final Map<String, Map<String, Serializable>> sessions = Coll.mapOfMaps();
 
-	public FastHttp(HttpRoutesImpl routes) {
+	public FastHttp(HttpRoutesImpl... routes) {
 		super(null);
-		this.routes = routes;
-		this.customization = routes.custom();
-	}
-
-	public FastHttp(Customization customization) {
-		this(new HttpRoutesImpl(customization));
-	}
+		U.must(routes.length > 0, "Routes are missing!");
 
-	public synchronized void on(String verb, String path, HttpHandler handler) {
-		routes.on(verb, path, handler);
-	}
-
-	public synchronized void on(String verb, String path, ReqHandler handler) {
-		routes.on(verb, path, handler);
+		this.routes = routes;
+		this.customization = routes[0].custom();
 	}
 
 	@SuppressWarnings("unchecked")
@@ -94,7 +84,27 @@ public void onRequest(Channel channel, boolean isGet, boolean isKeepAlive, BufRa
 		}
 
 		HttpStatus status = HttpStatus.NOT_FOUND;
-		HandlerMatch match = routes.findHandler(buf, isGet, xverb, xpath);
+
+		HttpRoutesImpl route = null;
+		HandlerMatch match = null;
+
+		for (HttpRoutesImpl r : routes) {
+			match = r.findHandler(buf, isGet, xverb, xpath);
+			if (match != null) {
+				route = r;
+				break;
+			}
+		}
+
+		if (match == null && isGet) {
+			for (HttpRoutesImpl r : routes) {
+				match = r.staticResourcesHandler();
+				if (match != null) {
+					route = r;
+					break;
+				}
+			}
+		}
 
 		HttpHandler handler = match != null ? match.getHandler() : null;
 		boolean noReq = (handler != null && !handler.needsParams());
@@ -160,7 +170,7 @@ public void onRequest(Channel channel, boolean isGet, boolean isKeepAlive, BufRa
 			cookies = Collections.synchronizedMap(cookies);
 
 			req = new ReqImpl(this, channel, isKeepAlive, verb, uri, path, query, body, params, headers, cookies,
-					posted, files, contentType, segment, routes);
+					posted, files, contentType, segment, route);
 
 			if (!attributes.isEmpty()) {
 				req.attrs().putAll(attributes);
@@ -201,7 +211,7 @@ private boolean handleError(Channel channel, boolean isKeepAlive, ReqImpl req, M
 		} else {
 			Log.error("Low-level HTTP handler error!", e);
 			HttpIO.startResponse(channel, 500, isKeepAlive, contentType);
-			byte[] bytes = HttpUtils.responseToBytes("Internal Server Error!", contentType, custom().jsonResponseRenderer());
+			byte[] bytes = HttpUtils.responseToBytes("Internal Server Error!", contentType, routes()[0].custom().jsonResponseRenderer());
 			HttpIO.writeContentLengthAndBody(channel, bytes);
 			HttpIO.done(channel, isKeepAlive);
 		}
@@ -221,37 +231,53 @@ private static String validateRequest(Buf input, BufRange verb, BufRange uri) {
 		return null; // OK, no error
 	}
 
-	private HttpStatus tryGenericHandlers(Channel channel, boolean isKeepAlive, Req req) {
-		for (HttpHandler handler : routes.genericHandlers()) {
+	private HttpStatus tryGenericHandlers(Channel channel, boolean isKeepAlive, ReqImpl req) {
+		for (HttpRoutesImpl route : routes) {
+
+			// trying with different routes
+			req.routes(route);
 
-			HttpStatus status = handler.handle(channel, isKeepAlive, req, null);
+			for (HttpHandler handler : route.genericHandlers()) {
+				HttpStatus status = handler.handle(channel, isKeepAlive, req, null);
 
-			if (status != HttpStatus.NOT_FOUND) {
-				return status;
+				if (status != HttpStatus.NOT_FOUND) {
+					return status;
+				}
 			}
 		}
 
+		req.routes(null);
+
 		return HttpStatus.NOT_FOUND;
 	}
 
 	public synchronized void resetConfig() {
-		routes.reset();
-		customization.reset();
+		for (HttpRoutesImpl route : routes) {
+			route.reset();
+			route.custom().reset();
+		}
 	}
 
 	public void notFound(Channel ctx, boolean isKeepAlive, HttpHandler fromHandler, Req req) {
-		List<HttpHandler> genericHandlers = routes.genericHandlers();
-		int count = genericHandlers.size();
-
 		HttpStatus status = HttpStatus.NOT_FOUND;
 
-		for (int i = 0; i < count; i++) {
-			HttpHandler handler = genericHandlers.get(i);
-			if (handler == fromHandler) {
-				if (i < count - 1) {
-					HttpHandler nextHandler = genericHandlers.get(i + 1);
-					status = nextHandler.handle(ctx, isKeepAlive, req, null);
-					break;
+		tryRoutes:
+		for (HttpRoutesImpl route : routes) {
+			List<HttpHandler> genericHandlers = route.genericHandlers();
+			int count = genericHandlers.size();
+
+			for (int i = 0; i < count; i++) {
+				HttpHandler handler = genericHandlers.get(i);
+				if (handler == fromHandler) {
+					// a generic handler returned "not found" -> go to the next one
+					if (i < count - 1) {
+						// trying with different routes
+						((ReqImpl) req).routes(route);
+
+						HttpHandler nextHandler = genericHandlers.get(i + 1);
+						status = nextHandler.handle(ctx, isKeepAlive, req, null);
+						break tryRoutes;
+					}
 				}
 			}
 		}
@@ -270,12 +296,15 @@ public Map<String, Serializable> session(String sessionId) {
 		return sessions.get(sessionId);
 	}
 
-	public Customization custom() {
-		return customization;
+	public HttpRoutesImpl[] routes() {
+		return routes;
 	}
 
-	public HttpRoutesImpl getRoutes() {
-		return routes;
+	public boolean hasRouteOrResource(HttpVerb verb, String uri) {
+		for (HttpRoutesImpl route : routes) {
+			if (route.hasRouteOrResource(verb, uri)) return true;
+		}
+		return false;
 	}
 
 }

rapidoid-http-fast/src/main/java/org/rapidoid/http/HttpRoutes.java

@@ -52,4 +52,7 @@ public interface HttpRoutes {
 	Customization custom();
 
 	Route find(HttpVerb verb, String path);
+
+	boolean hasRouteOrResource(HttpVerb verb, String uri);
+
 }

rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/AbstractAsyncHttpHandler.java

@@ -45,9 +45,12 @@ public abstract class AbstractAsyncHttpHandler extends AbstractHttpHandler {
 
 	private final FastHttp http;
 
-	public AbstractAsyncHttpHandler(FastHttp http, RouteOptions options) {
+	private final HttpRoutes routes;
+
+	public AbstractAsyncHttpHandler(FastHttp http, HttpRoutes routes, RouteOptions options) {
 		super(options);
 		this.http = http;
+		this.routes = routes;
 	}
 
 	@Override
@@ -65,14 +68,14 @@ public HttpStatus handle(Channel ctx, boolean isKeepAlive, Req req, Object extra
 			req.response().logout();
 		}
 
-		Set<String> roles = userRoles(username);
+		Set<String> roles = userRoles(req, username);
 
 		TransactionMode txMode;
 		try {
 			txMode = before(req, username, roles);
 
 		} catch (Throwable e) {
-			HttpIO.errorAndDone(req, e, http.custom().errorHandler());
+			HttpIO.errorAndDone(req, e, req.routes().custom().errorHandler());
 			return HttpStatus.DONE;
 		}
 
@@ -84,7 +87,7 @@ public HttpStatus handle(Channel ctx, boolean isKeepAlive, Req req, Object extra
 
 		} catch (Throwable e) {
 			// if there was an error in the job scheduling:
-			HttpIO.errorAndDone(req, e, http.custom().errorHandler());
+			HttpIO.errorAndDone(req, e, req.custom().errorHandler());
 			return HttpStatus.DONE;
 		}
 
@@ -110,10 +113,10 @@ private String getUser(Req req) {
 		}
 	}
 
-	private Set<String> userRoles(String username) {
+	private Set<String> userRoles(Req req, String username) {
 		if (username != null) {
 			try {
-				return http.custom().rolesProvider().getRolesForUser(username);
+				return req.routes().custom().rolesProvider().getRolesForUser(username);
 			} catch (Exception e) {
 				throw U.rte(e);
 			}
@@ -197,7 +200,7 @@ public void run() {
 					try {
 						JPA.transaction(handleRequest, txMode == TransactionMode.READ_ONLY);
 					} catch (Exception e) {
-						HttpIO.errorAndDone(req, e, http.custom().errorHandler());
+						HttpIO.errorAndDone(req, e, req.routes().custom().errorHandler());
 					}
 				}
 			};
@@ -256,7 +259,7 @@ public void complete(Channel ctx, boolean isKeepAlive, Req req, Object result) {
 		}
 
 		if (result instanceof Throwable) {
-			HttpIO.errorAndDone(req, (Throwable) result, http.custom().errorHandler());
+			HttpIO.errorAndDone(req, (Throwable) result, req.routes().custom().errorHandler());
 			return;
 
 		} else {

rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/ParamsAwareReqHandler.java

@@ -23,6 +23,7 @@
 import org.rapidoid.annotation.Authors;
 import org.rapidoid.annotation.Since;
 import org.rapidoid.http.FastHttp;
+import org.rapidoid.http.HttpRoutes;
 import org.rapidoid.http.Req;
 import org.rapidoid.http.ReqHandler;
 import org.rapidoid.http.impl.RouteOptions;
@@ -34,8 +35,8 @@ public class ParamsAwareReqHandler extends AbstractAsyncHttpHandler {
 
 	private final ReqHandler handler;
 
-	public ParamsAwareReqHandler(FastHttp http, RouteOptions options, ReqHandler handler) {
-		super(http, options);
+	public ParamsAwareReqHandler(FastHttp http, HttpRoutes routes, RouteOptions options, ReqHandler handler) {
+		super(http, routes, options);
 		this.handler = handler;
 	}
 

rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/PredefinedResponseHandler.java

@@ -23,6 +23,7 @@
 import org.rapidoid.annotation.Authors;
 import org.rapidoid.annotation.Since;
 import org.rapidoid.http.FastHttp;
+import org.rapidoid.http.HttpRoutes;
 import org.rapidoid.http.Req;
 import org.rapidoid.http.impl.RouteOptions;
 import org.rapidoid.net.abstracts.Channel;
@@ -33,8 +34,8 @@ public class PredefinedResponseHandler extends AbstractAsyncHttpHandler {
 
 	private final Object response;
 
-	public PredefinedResponseHandler(FastHttp http, RouteOptions options, Object response) {
-		super(http, options);
+	public PredefinedResponseHandler(FastHttp http, HttpRoutes routes, RouteOptions options, Object response) {
+		super(http, routes, options);
 		this.response = response;
 	}
 

rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/HttpRoutesImpl.java

@@ -21,6 +21,7 @@
 import org.rapidoid.http.handler.HttpHandler;
 import org.rapidoid.http.handler.ParamsAwareReqHandler;
 import org.rapidoid.http.handler.StaticResourcesHandler;
+import org.rapidoid.io.Res;
 import org.rapidoid.log.Log;
 import org.rapidoid.u.U;
 import org.rapidoid.util.AnsiColor;
@@ -88,7 +89,7 @@ public class HttpRoutesImpl extends RapidoidThing implements HttpRoutes {
 
 	final List<HttpHandler> genericHandlers = Coll.synchronizedList();
 
-	volatile HttpHandler staticResourcesHandler;
+	private volatile HttpHandler staticResourcesHandler;
 
 	private final Set<Route> routes = Coll.synchronizedSet();
 
@@ -307,10 +308,6 @@ public HandlerMatch findHandler(Buf buf, boolean isGet, BufRange verb, BufRange
 					handler = matchByPattern(paternGetHandlers, buf.get(path));
 				}
 
-				if (handler == null) {
-					handler = staticResourcesHandler;
-				}
-
 				return handler;
 			}
 
@@ -406,7 +403,7 @@ public synchronized void on(String verb, String path, ReqHandler handler) {
 	}
 
 	public HttpHandler handler(ReqHandler reqHandler, RouteOptions options) {
-		return new ParamsAwareReqHandler(null, options, reqHandler);
+		return new ParamsAwareReqHandler(null, null, options, reqHandler);
 	}
 
 	@Override
@@ -528,7 +525,26 @@ public Route find(HttpVerb verb, String path) {
 		return null;
 	}
 
+	@Override
+	public boolean hasRouteOrResource(HttpVerb verb, String uri) {
+		if (verb == HttpVerb.GET) {
+			String[] staticFilesLocations = custom().staticFilesPath();
+			if (U.notEmpty(staticFilesLocations)) {
+				String filename = Str.triml(uri, '/');
+				if (filename.isEmpty()) filename = "index.html";
+				if (Res.from(filename, staticFilesLocations).exists()) return true;
+			}
+		}
+
+		return find(verb, uri) != null;
+	}
+
 	public List<HttpHandler> genericHandlers() {
 		return genericHandlers;
 	}
+
+	public HttpHandler staticResourcesHandler() {
+		return staticResourcesHandler;
+	}
+
 }

rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/RapidoidReqInfo.java

@@ -124,7 +124,7 @@ public String view() {
 	@Override
 	public boolean hasRoute(HttpVerb verb, String uri) {
 		ReqImpl reqq = (ReqImpl) req();
-		return reqq.hasRoute(verb, uri);
+		return reqq.http().hasRouteOrResource(verb, uri);
 	}
 
 	private Req req() {