diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/FastHttp.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/FastHttp.java index dddcbedb68..969b713d09 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/FastHttp.java +++ b/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 attributes = Coll.synchronizedMap(); private final Map> 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 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 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 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; } } diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/HttpRoutes.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/HttpRoutes.java index dac134ffb1..e071cf8fe1 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/HttpRoutes.java +++ b/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); + } diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/AbstractAsyncHttpHandler.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/AbstractAsyncHttpHandler.java index 64b2ea93e5..4c2f9aa342 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/AbstractAsyncHttpHandler.java +++ b/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 roles = userRoles(username); + Set 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 userRoles(String username) { + private Set 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 { diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/ParamsAwareReqHandler.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/ParamsAwareReqHandler.java index 824ae38c27..2278327796 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/ParamsAwareReqHandler.java +++ b/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; } diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/PredefinedResponseHandler.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/PredefinedResponseHandler.java index 5a7bb334f8..5bb31c93e4 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/handler/PredefinedResponseHandler.java +++ b/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; } diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/HttpRoutesImpl.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/HttpRoutesImpl.java index 18a5ede28d..610f5ab9ac 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/HttpRoutesImpl.java +++ b/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 genericHandlers = Coll.synchronizedList(); - volatile HttpHandler staticResourcesHandler; + private volatile HttpHandler staticResourcesHandler; private final Set 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 genericHandlers() { return genericHandlers; } + + public HttpHandler staticResourcesHandler() { + return staticResourcesHandler; + } + } diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/RapidoidReqInfo.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/RapidoidReqInfo.java index f5e617a2b5..d3f9ccd315 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/RapidoidReqInfo.java +++ b/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() { diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/ReqImpl.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/ReqImpl.java index 875fca0701..c48da271fb 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/ReqImpl.java +++ b/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/ReqImpl.java @@ -8,8 +8,8 @@ import org.rapidoid.commons.MediaType; import org.rapidoid.commons.Str; import org.rapidoid.http.*; +import org.rapidoid.http.customize.BeanParameterFactory; import org.rapidoid.http.customize.Customization; -import org.rapidoid.io.Res; import org.rapidoid.io.Upload; import org.rapidoid.log.Log; import org.rapidoid.net.abstracts.Channel; @@ -100,7 +100,7 @@ public class ReqImpl extends RapidoidThing implements Req, Constants, HttpMetada private final MediaType defaultContentType; - private final HttpRoutesImpl routes; + private volatile HttpRoutesImpl routes; public ReqImpl(FastHttp http, Channel channel, boolean isKeepAlive, String verb, String uri, String path, String query, byte[] body, Map params, Map headers, @@ -335,10 +335,13 @@ public T data(Class beanType) { return beanFrom(beanType, data()); } + @SuppressWarnings("unchecked") private T beanFrom(Class beanType, Map properties) { String paramName = Str.uncapitalized(beanType.getSimpleName()); + BeanParameterFactory beanParameterFactory = custom().beanParameterFactory(); + try { - return (T) http.custom().beanParameterFactory().getParamValue(this, beanType, paramName, (Map) properties); + return (T) beanParameterFactory.getParamValue(this, beanType, paramName, (Map) properties); } catch (Exception e) { throw new RuntimeException("Couldn't instantiate a bean of type: " + beanType.getName()); } @@ -512,7 +515,7 @@ private byte[] responseToBytes() { return response.renderToBytes(); } catch (Throwable e) { - HttpIO.error(this, e, http.custom().errorHandler()); + HttpIO.error(this, e, custom().errorHandler()); try { return response.renderToBytes(); @@ -566,6 +569,11 @@ public HttpRoutes routes() { return routes; } + public ReqImpl routes(HttpRoutesImpl routes) { + this.routes = routes; + return this; + } + @Override public Customization custom() { return routes.custom(); @@ -681,7 +689,7 @@ public String contextPath() { if (contextPath == null) { synchronized (this) { if (contextPath == null) { - contextPath = HttpUtils.getContextPath(routes.custom(), segment()); + contextPath = HttpUtils.getContextPath(custom(), segment()); } } } @@ -722,18 +730,4 @@ public boolean isStopped() { return stopped; } - public boolean hasRoute(HttpVerb verb, String uri) { - if (verb == HttpVerb.GET) { - String[] staticFilesLocations = custom().staticFilesPath(); - if (U.notEmpty(staticFilesLocations)) { - String filename = Str.triml(uri, '/'); - if (Res.from(filename, staticFilesLocations).exists()) { - return true; - } - } - } - - return routes().find(verb, uri) != null; - } - } diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/RespImpl.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/RespImpl.java index aee8d03210..3a81ea85de 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/RespImpl.java +++ b/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/RespImpl.java @@ -321,10 +321,10 @@ public Req request() { @Override public boolean login(String username, String password) { - LoginProvider loginProvider = req.http().custom().loginProvider(); + LoginProvider loginProvider = req.routes().custom().loginProvider(); U.must(loginProvider != null, "A login provider wasn't set!"); - RolesProvider rolesProvider = req.http().custom().rolesProvider(); + RolesProvider rolesProvider = req.routes().custom().rolesProvider(); U.must(rolesProvider != null, "A roles provider wasn't set!"); boolean success; @@ -453,7 +453,7 @@ public byte[] renderToBytes() { } private byte[] serializeResponseContent() { - return HttpUtils.responseToBytes(result(), contentType(), req.http().custom().jsonResponseRenderer()); + return HttpUtils.responseToBytes(result(), contentType(), req.routes().custom().jsonResponseRenderer()); } } diff --git a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/ResponseRenderer.java b/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/ResponseRenderer.java index d18ee0b65b..e0003bafa9 100644 --- a/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/ResponseRenderer.java +++ b/rapidoid-http-fast/src/main/java/org/rapidoid/http/impl/ResponseRenderer.java @@ -49,10 +49,10 @@ public static byte[] render(ReqImpl req, Resp resp) { resp.result(result); } - ViewRenderer viewRenderer = req.http().custom().viewRenderer(); + ViewRenderer viewRenderer = req.routes().custom().viewRenderer(); U.must(viewRenderer != null, "A view renderer wasn't configured!"); - PageRenderer pageRenderer = req.http().custom().pageRenderer(); + PageRenderer pageRenderer = req.routes().custom().pageRenderer(); U.must(pageRenderer != null, "A page renderer wasn't configured!"); boolean rendered; diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/HttpHandlers.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/HttpHandlers.java index fb2409ec47..0c86ae86af 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/HttpHandlers.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/HttpHandlers.java @@ -41,12 +41,12 @@ @Since("5.1.0") public class HttpHandlers extends RapidoidThing { - public static HttpHandler from(FastHttp http, NParamLambda handler, RouteOptions options) { + public static HttpHandler from(FastHttp http, HttpRoutes routes, NParamLambda handler, RouteOptions options) { if (handler instanceof ReqHandler) { - return new DelegatingParamsAwareReqHandler(http, options, (ReqHandler) handler); + return new DelegatingParamsAwareReqHandler(http, routes, options, (ReqHandler) handler); } else if (handler instanceof ReqRespHandler) { - return new DelegatingParamsAwareReqRespHandler(http, options, (ReqRespHandler) handler); + return new DelegatingParamsAwareReqRespHandler(http, routes, options, (ReqRespHandler) handler); } else if (handler instanceof OneParamLambda) { @@ -55,11 +55,11 @@ public static HttpHandler from(FastHttp http, NParamLambda handler, RouteOptions Class paramType = method.getParameterTypes()[0]; if (paramType.equals(Req.class)) { - return new DelegatingParamsAwareReqHandler(http, options, lambda); + return new DelegatingParamsAwareReqHandler(http, routes, options, lambda); } else if (paramType.equals(Resp.class)) { - return new DelegatingParamsAwareRespHandler(http, options, lambda); + return new DelegatingParamsAwareRespHandler(http, routes, options, lambda); } else { - return new OneParamLambdaHandler(http, options, lambda); + return new OneParamLambdaHandler(http, routes, options, lambda); } } else if (handler instanceof TwoParamLambda) { @@ -70,51 +70,51 @@ public static HttpHandler from(FastHttp http, NParamLambda handler, RouteOptions Class param2Type = method.getParameterTypes()[1]; if (param1Type.equals(Req.class) && param2Type.equals(Resp.class)) { - return new DelegatingParamsAwareReqRespHandler(http, options, lambda); + return new DelegatingParamsAwareReqRespHandler(http, routes, options, lambda); } else { - return new TwoParamLambdaHandler(http, options, (TwoParamLambda) handler); + return new TwoParamLambdaHandler(http, routes, options, (TwoParamLambda) handler); } } else if (handler instanceof ThreeParamLambda) { - return new ThreeParamLambdaHandler(http, options, (ThreeParamLambda) handler); + return new ThreeParamLambdaHandler(http, routes, options, (ThreeParamLambda) handler); } else if (handler instanceof FourParamLambda) { - return new FourParamLambdaHandler(http, options, (FourParamLambda) handler); + return new FourParamLambdaHandler(http, routes, options, (FourParamLambda) handler); } else if (handler instanceof FiveParamLambda) { - return new FiveParamLambdaHandler(http, options, (FiveParamLambda) handler); + return new FiveParamLambdaHandler(http, routes, options, (FiveParamLambda) handler); } else if (handler instanceof SixParamLambda) { - return new SixParamLambdaHandler(http, options, (SixParamLambda) handler); + return new SixParamLambdaHandler(http, routes, options, (SixParamLambda) handler); } else if (handler instanceof SevenParamLambda) { - return new SevenParamLambdaHandler(http, options, (SevenParamLambda) handler); + return new SevenParamLambdaHandler(http, routes, options, (SevenParamLambda) handler); } else { throw Err.notExpected(); } } - public static void registerStatic(FastHttp http, String verb, String path, RouteOptions options, byte[] response) { - http.on(verb, path, new StaticHttpHandler(options, response)); + public static void registerStatic(FastHttp http, HttpRoutes routes, String verb, String path, RouteOptions options, byte[] response) { + routes.on(verb, path, new StaticHttpHandler(options, response)); } - public static void registerPredefined(FastHttp http, String verb, String path, RouteOptions options, Object response) { - http.on(verb, path, new PredefinedResponseHandler(http, options, response)); + public static void registerPredefined(FastHttp http, HttpRoutes routes, String verb, String path, RouteOptions options, Object response) { + routes.on(verb, path, new PredefinedResponseHandler(http, routes, options, response)); } @SuppressWarnings("unchecked") - public static void register(FastHttp http, String verb, String path, RouteOptions options, Callable handler) { - http.on(verb, path, new CallableHttpHandler(http, options, (Callable) handler)); + public static void register(FastHttp http, HttpRoutes routes, String verb, String path, RouteOptions options, Callable handler) { + routes.on(verb, path, new CallableHttpHandler(http, routes, options, (Callable) handler)); } - public static void register(FastHttp http, String verb, String path, RouteOptions options, NParamLambda lambda) { - HttpHandler handler = HttpHandlers.from(http, lambda, options); - http.on(verb, path, handler); + public static void register(FastHttp http, HttpRoutes routes, String verb, String path, RouteOptions options, NParamLambda lambda) { + HttpHandler handler = HttpHandlers.from(http, routes, lambda, options); + routes.on(verb, path, handler); } - public static void register(FastHttp http, String verb, String path, RouteOptions options, Method method, Object instance) { - http.on(verb, path, new MethodReqHandler(http, options, method, instance)); + public static void register(FastHttp http, HttpRoutes routes, String verb, String path, RouteOptions options, Method method, Object instance) { + routes.on(verb, path, new MethodReqHandler(http, routes, options, method, instance)); } } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/MethodReqHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/MethodReqHandler.java index 76103d444b..5aa10191f9 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/MethodReqHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/MethodReqHandler.java @@ -4,9 +4,10 @@ import org.rapidoid.annotation.Since; import org.rapidoid.cls.Cls; import org.rapidoid.http.FastHttp; +import org.rapidoid.http.HttpRoutes; import org.rapidoid.http.Req; -import org.rapidoid.http.impl.RouteOptions; import org.rapidoid.http.handler.lambda.NParamMethodHandler; +import org.rapidoid.http.impl.RouteOptions; import org.rapidoid.net.abstracts.Channel; import org.rapidoid.u.U; @@ -38,8 +39,8 @@ public class MethodReqHandler extends NParamMethodHandler { private final Object instance; - public MethodReqHandler(FastHttp http, RouteOptions options, Method method, Object instance) { - super(http, options, method, null); + public MethodReqHandler(FastHttp http, HttpRoutes routes, RouteOptions options, Method method, Object instance) { + super(http, routes, options, method, null); this.instance = instance; } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/FiveParamLambdaHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/FiveParamLambdaHandler.java index 156b530a12..68aeabba5f 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/FiveParamLambdaHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/FiveParamLambdaHandler.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.lambda.FiveParamLambda; @@ -35,8 +36,8 @@ public class FiveParamLambdaHandler extends NParamLambdaHandler { private final FiveParamLambda lambda; - public FiveParamLambdaHandler(FastHttp http, RouteOptions options, FiveParamLambda lambda) { - super(http, options, lambda); + public FiveParamLambdaHandler(FastHttp http, HttpRoutes routes, RouteOptions options, FiveParamLambda lambda) { + super(http, routes, options, lambda); this.lambda = U.cast(lambda); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/FourParamLambdaHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/FourParamLambdaHandler.java index a0f98711d2..80922f144c 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/FourParamLambdaHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/FourParamLambdaHandler.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.lambda.FourParamLambda; @@ -35,8 +36,8 @@ public class FourParamLambdaHandler extends NParamLambdaHandler { private final FourParamLambda lambda; - public FourParamLambdaHandler(FastHttp http, RouteOptions options , FourParamLambda lambda) { - super(http, options, lambda); + public FourParamLambdaHandler(FastHttp http, HttpRoutes routes, RouteOptions options, FourParamLambda lambda) { + super(http, routes, options, lambda); this.lambda = U.cast(lambda); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/NParamLambdaHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/NParamLambdaHandler.java index b3c2ec1a10..4679d1074f 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/NParamLambdaHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/NParamLambdaHandler.java @@ -24,6 +24,7 @@ import org.rapidoid.annotation.Since; import org.rapidoid.cls.Cls; import org.rapidoid.http.FastHttp; +import org.rapidoid.http.HttpRoutes; import org.rapidoid.http.impl.RouteOptions; import org.rapidoid.lambda.NParamLambda; @@ -31,8 +32,8 @@ @Since("5.1.0") public abstract class NParamLambdaHandler extends NParamMethodHandler { - public NParamLambdaHandler(FastHttp http, RouteOptions options, NParamLambda lambda) { - super(http, options, Cls.getLambdaMethod(lambda), lambda); + public NParamLambdaHandler(FastHttp http, HttpRoutes routes, RouteOptions options, NParamLambda lambda) { + super(http, routes, options, Cls.getLambdaMethod(lambda), lambda); } @Override diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/NParamMethodHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/NParamMethodHandler.java index 7731ad9366..03ccd73143 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/NParamMethodHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/NParamMethodHandler.java @@ -5,11 +5,12 @@ import org.rapidoid.cls.Cls; import org.rapidoid.commons.Arr; import org.rapidoid.http.FastHttp; +import org.rapidoid.http.HttpRoutes; import org.rapidoid.http.Req; -import org.rapidoid.http.impl.RouteOptions; import org.rapidoid.http.handler.AbstractAsyncHttpHandler; import org.rapidoid.http.handler.param.ParamRetriever; import org.rapidoid.http.handler.param.ParamRetrievers; +import org.rapidoid.http.impl.RouteOptions; import org.rapidoid.lambda.NParamLambda; import java.lang.annotation.Annotation; @@ -45,8 +46,8 @@ public abstract class NParamMethodHandler extends AbstractAsyncHttpHandler { private final String paramsAsStr; - public NParamMethodHandler(FastHttp http, RouteOptions options, Method method, NParamLambda lambda) { - super(http, options); + public NParamMethodHandler(FastHttp http, HttpRoutes routes, RouteOptions options, Method method, NParamLambda lambda) { + super(http, routes, options); this.method = method; Class[] paramTypes = method.getParameterTypes(); @@ -65,7 +66,7 @@ public NParamMethodHandler(FastHttp http, RouteOptions options, Method method, N String par = ""; for (int i = 0; i < paramRetrievers.length; i++) { - paramRetrievers[i] = ParamRetrievers.createParamRetriever(http.custom(), paramTypes[i], paramNames[i], annotations[i]); + paramRetrievers[i] = ParamRetrievers.createParamRetriever(routes.custom(), paramTypes[i], paramNames[i], annotations[i]); if (i > 0) { par += ", "; } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/OneParamLambdaHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/OneParamLambdaHandler.java index 024b688172..4eac4865c1 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/OneParamLambdaHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/OneParamLambdaHandler.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.lambda.OneParamLambda; @@ -35,8 +36,8 @@ public class OneParamLambdaHandler extends NParamLambdaHandler { private final OneParamLambda lambda; - public OneParamLambdaHandler(FastHttp http, RouteOptions options, OneParamLambda lambda) { - super(http, options, lambda); + public OneParamLambdaHandler(FastHttp http, HttpRoutes routes, RouteOptions options, OneParamLambda lambda) { + super(http, routes, options, lambda); this.lambda = U.cast(lambda); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/SevenParamLambdaHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/SevenParamLambdaHandler.java index 4a23e71e54..4bf902152c 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/SevenParamLambdaHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/SevenParamLambdaHandler.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.lambda.SevenParamLambda; @@ -35,8 +36,8 @@ public class SevenParamLambdaHandler extends NParamLambdaHandler { private final SevenParamLambda lambda; - public SevenParamLambdaHandler(FastHttp http, RouteOptions options, SevenParamLambda lambda) { - super(http, options, lambda); + public SevenParamLambdaHandler(FastHttp http, HttpRoutes routes, RouteOptions options, SevenParamLambda lambda) { + super(http, routes, options, lambda); this.lambda = U.cast(lambda); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/SixParamLambdaHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/SixParamLambdaHandler.java index 3a45a87fed..0344cbbdd0 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/SixParamLambdaHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/SixParamLambdaHandler.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.lambda.SixParamLambda; @@ -35,8 +36,8 @@ public class SixParamLambdaHandler extends NParamLambdaHandler { private final SixParamLambda lambda; - public SixParamLambdaHandler(FastHttp http, RouteOptions options, SixParamLambda lambda) { - super(http, options, lambda); + public SixParamLambdaHandler(FastHttp http, HttpRoutes routes, RouteOptions options, SixParamLambda lambda) { + super(http, routes, options, lambda); this.lambda = U.cast(lambda); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/ThreeParamLambdaHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/ThreeParamLambdaHandler.java index 564772f456..e089b59eb0 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/ThreeParamLambdaHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/ThreeParamLambdaHandler.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.lambda.ThreeParamLambda; @@ -35,8 +36,8 @@ public class ThreeParamLambdaHandler extends NParamLambdaHandler { private final ThreeParamLambda lambda; - public ThreeParamLambdaHandler(FastHttp http, RouteOptions options, ThreeParamLambda lambda) { - super(http, options, lambda); + public ThreeParamLambdaHandler(FastHttp http, HttpRoutes routes, RouteOptions options, ThreeParamLambda lambda) { + super(http, routes, options, lambda); this.lambda = U.cast(lambda); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/TwoParamLambdaHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/TwoParamLambdaHandler.java index b7c3026f4f..978dd51bfb 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/TwoParamLambdaHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/lambda/TwoParamLambdaHandler.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.lambda.TwoParamLambda; @@ -35,8 +36,8 @@ public class TwoParamLambdaHandler extends NParamLambdaHandler { private final TwoParamLambda lambda; - public TwoParamLambdaHandler(FastHttp http, RouteOptions options, TwoParamLambda lambda) { - super(http, options, lambda); + public TwoParamLambdaHandler(FastHttp http, HttpRoutes routes, RouteOptions options, TwoParamLambda lambda) { + super(http, routes, options, lambda); this.lambda = U.cast(lambda); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/CallableHttpHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/CallableHttpHandler.java index cc516b571b..a1442023ac 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/CallableHttpHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/CallableHttpHandler.java @@ -3,6 +3,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.http.handler.AbstractAsyncHttpHandler; @@ -36,8 +37,8 @@ public class CallableHttpHandler extends AbstractAsyncHttpHandler { private final Callable handler; - public CallableHttpHandler(FastHttp http, RouteOptions options, Callable handler) { - super(http, options); + public CallableHttpHandler(FastHttp http, HttpRoutes routes, RouteOptions options, Callable handler) { + super(http, routes, options); this.handler = handler; } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareReqHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareReqHandler.java index 1e22a9ef0f..0ba62e0f1c 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareReqHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareReqHandler.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.http.handler.AbstractAsyncHttpHandler; @@ -36,8 +37,8 @@ public class DelegatingParamsAwareReqHandler extends AbstractAsyncHttpHandler { private final OneParamLambda handler; - public DelegatingParamsAwareReqHandler(FastHttp http, RouteOptions options, OneParamLambda handler) { - super(http, options); + public DelegatingParamsAwareReqHandler(FastHttp http, HttpRoutes routes, RouteOptions options, OneParamLambda handler) { + super(http, routes, options); this.handler = U.cast(handler); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareReqRespHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareReqRespHandler.java index d5c17ecd7d..4bcb0ab928 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareReqRespHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareReqRespHandler.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.Resp; import org.rapidoid.http.impl.RouteOptions; @@ -37,8 +38,8 @@ public class DelegatingParamsAwareReqRespHandler extends AbstractAsyncHttpHandle private final TwoParamLambda handler; - public DelegatingParamsAwareReqRespHandler(FastHttp http, RouteOptions options, TwoParamLambda handler) { - super(http, options); + public DelegatingParamsAwareReqRespHandler(FastHttp http, HttpRoutes routes, RouteOptions options, TwoParamLambda handler) { + super(http, routes, options); this.handler = U.cast(handler); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareRespHandler.java b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareRespHandler.java index 731502da2c..fd8cccef35 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareRespHandler.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/http/handler/optimized/DelegatingParamsAwareRespHandler.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.Resp; import org.rapidoid.http.impl.RouteOptions; @@ -37,8 +38,8 @@ public class DelegatingParamsAwareRespHandler extends AbstractAsyncHttpHandler { private final OneParamLambda handler; - public DelegatingParamsAwareRespHandler(FastHttp http, RouteOptions options, OneParamLambda handler) { - super(http, options); + public DelegatingParamsAwareRespHandler(FastHttp http, HttpRoutes routes, RouteOptions options, OneParamLambda handler) { + super(http, routes, options); this.handler = U.cast(handler); } diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/setup/OnRoute.java b/rapidoid-http-server/src/main/java/org/rapidoid/setup/OnRoute.java index aa4684c0d8..1ad0d2ef56 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/setup/OnRoute.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/setup/OnRoute.java @@ -5,10 +5,7 @@ import org.rapidoid.annotation.Since; import org.rapidoid.annotation.TransactionMode; import org.rapidoid.commons.MediaType; -import org.rapidoid.http.FastHttp; -import org.rapidoid.http.HttpWrapper; -import org.rapidoid.http.ReqHandler; -import org.rapidoid.http.ReqRespHandler; +import org.rapidoid.http.*; import org.rapidoid.http.handler.HttpHandlers; import org.rapidoid.http.impl.RouteOptions; import org.rapidoid.lambda.*; @@ -44,14 +41,17 @@ public class OnRoute extends RapidoidThing { private final FastHttp http; + private final HttpRoutes routes; + private final String verb; private final String path; private final RouteOptions options; - public OnRoute(FastHttp http, RouteOptions defaults, String verb, String path) { + public OnRoute(FastHttp http, RouteOptions defaults, HttpRoutes routes, String verb, String path) { this.http = http; + this.routes = routes; this.verb = verb; this.path = path; this.options = defaults.copy(); @@ -60,287 +60,287 @@ public OnRoute(FastHttp http, RouteOptions defaults, String verb, String path) { /* GENERIC */ public void serve(String response) { - HttpHandlers.registerPredefined(http, verb, path, options, response); + HttpHandlers.registerPredefined(http, routes, verb, path, options, response); } public void serve(byte[] response) { - HttpHandlers.registerPredefined(http, verb, path, options, response); + HttpHandlers.registerPredefined(http, routes, verb, path, options, response); } public void serve(Callable handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } public void serve(Method method, Object instance) { - HttpHandlers.register(http, verb, path, options, method, instance); + HttpHandlers.register(http, routes, verb, path, options, method, instance); } public void serve(ReqHandler handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } public void serve(ReqRespHandler handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } public void serve(OneParamLambda handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } public void serve(TwoParamLambda handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } public void serve(ThreeParamLambda handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } public void serve(FourParamLambda handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } public void serve(FiveParamLambda handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } public void serve(SixParamLambda handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } public void serve(SevenParamLambda handler) { - HttpHandlers.register(http, verb, path, options, handler); + HttpHandlers.register(http, routes, verb, path, options, handler); } /* HTML */ public void staticHtml(byte[] response) { - HttpHandlers.registerStatic(http, verb, path, htmlOpts(), response); + HttpHandlers.registerStatic(http, routes, verb, path, htmlOpts(), response); } public void html(String response) { - HttpHandlers.registerPredefined(http, verb, path, htmlOpts(), response); + HttpHandlers.registerPredefined(http, routes, verb, path, htmlOpts(), response); } public void html(byte[] response) { - HttpHandlers.registerPredefined(http, verb, path, htmlOpts(), response); + HttpHandlers.registerPredefined(http, routes, verb, path, htmlOpts(), response); } public void html(Callable handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } public void html(Method method, Object instance) { - HttpHandlers.register(http, verb, path, htmlOpts(), method, instance); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), method, instance); } public void html(ReqHandler handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } public void html(ReqRespHandler handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } public void html(OneParamLambda handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } public void html(TwoParamLambda handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } public void html(ThreeParamLambda handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } public void html(FourParamLambda handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } public void html(FiveParamLambda handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } public void html(SixParamLambda handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } public void html(SevenParamLambda handler) { - HttpHandlers.register(http, verb, path, htmlOpts(), handler); + HttpHandlers.register(http, routes, verb, path, htmlOpts(), handler); } /* JSON */ public void staticJson(byte[] response) { - HttpHandlers.registerStatic(http, verb, path, jsonOpts(), response); + HttpHandlers.registerStatic(http, routes, verb, path, jsonOpts(), response); } public void json(String response) { - HttpHandlers.registerPredefined(http, verb, path, jsonOpts(), response); + HttpHandlers.registerPredefined(http, routes, verb, path, jsonOpts(), response); } public void json(byte[] response) { - HttpHandlers.registerPredefined(http, verb, path, jsonOpts(), response); + HttpHandlers.registerPredefined(http, routes, verb, path, jsonOpts(), response); } public void json(Callable handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } public void json(Method method, Object instance) { - HttpHandlers.register(http, verb, path, jsonOpts(), method, instance); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), method, instance); } public void json(ReqHandler handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } public void json(ReqRespHandler handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } public void json(OneParamLambda handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } public void json(TwoParamLambda handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } public void json(ThreeParamLambda handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } public void json(FourParamLambda handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } public void json(FiveParamLambda handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } public void json(SixParamLambda handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } public void json(SevenParamLambda handler) { - HttpHandlers.register(http, verb, path, jsonOpts(), handler); + HttpHandlers.register(http, routes, verb, path, jsonOpts(), handler); } /* PLAIN */ public void staticPlain(byte[] response) { - HttpHandlers.registerStatic(http, verb, path, plainOpts(), response); + HttpHandlers.registerStatic(http, routes, verb, path, plainOpts(), response); } public void plain(String response) { - HttpHandlers.registerPredefined(http, verb, path, plainOpts(), response); + HttpHandlers.registerPredefined(http, routes, verb, path, plainOpts(), response); } public void plain(byte[] response) { - HttpHandlers.registerPredefined(http, verb, path, plainOpts(), response); + HttpHandlers.registerPredefined(http, routes, verb, path, plainOpts(), response); } public void plain(Callable handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } public void plain(Method method, Object instance) { - HttpHandlers.register(http, verb, path, plainOpts(), method, instance); + HttpHandlers.register(http, routes, verb, path, plainOpts(), method, instance); } public void plain(ReqHandler handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } public void plain(ReqRespHandler handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } public void plain(OneParamLambda handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } public void plain(TwoParamLambda handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } public void plain(ThreeParamLambda handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } public void plain(FourParamLambda handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } public void plain(FiveParamLambda handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } public void plain(SixParamLambda handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } public void plain(SevenParamLambda handler) { - HttpHandlers.register(http, verb, path, plainOpts(), handler); + HttpHandlers.register(http, routes, verb, path, plainOpts(), handler); } /* MVC */ public void mvc(String response) { - HttpHandlers.registerPredefined(http, verb, path, mvcOpts(), response); + HttpHandlers.registerPredefined(http, routes, verb, path, mvcOpts(), response); } public void mvc(Collection response) { - HttpHandlers.registerPredefined(http, verb, path, mvcOpts(), response); + HttpHandlers.registerPredefined(http, routes, verb, path, mvcOpts(), response); } public void mvc(Map response) { - HttpHandlers.registerPredefined(http, verb, path, mvcOpts(), response); + HttpHandlers.registerPredefined(http, routes, verb, path, mvcOpts(), response); } public void mvc(Callable handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } public void mvc(Method method, Object instance) { - HttpHandlers.register(http, verb, path, mvcOpts(), method, instance); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), method, instance); } public void mvc(ReqHandler handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } public void mvc(ReqRespHandler handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } public void mvc(OneParamLambda handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } public void mvc(TwoParamLambda handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } public void mvc(ThreeParamLambda handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } public void mvc(FourParamLambda handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } public void mvc(FiveParamLambda handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } public void mvc(SixParamLambda handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } public void mvc(SevenParamLambda handler) { - HttpHandlers.register(http, verb, path, mvcOpts(), handler); + HttpHandlers.register(http, routes, verb, path, mvcOpts(), handler); } /* CONTENT TYPE */ diff --git a/rapidoid-http-server/src/main/java/org/rapidoid/setup/Setup.java b/rapidoid-http-server/src/main/java/org/rapidoid/setup/Setup.java index 8d5420f7eb..39e4de1dde 100644 --- a/rapidoid-http-server/src/main/java/org/rapidoid/setup/Setup.java +++ b/rapidoid-http-server/src/main/java/org/rapidoid/setup/Setup.java @@ -164,7 +164,11 @@ public FastHttp http() { } if (http == null) { - http = new FastHttp(routes); + if (isAppOrAdminOnSameServer()) { + http = new FastHttp(ON.routes, ADMIN.routes); + } else { + http = new FastHttp(routes); + } } } @@ -193,7 +197,7 @@ public synchronized Server listen() { } if (server == null) { - if (appAndAdminOnSameServer() && (isApp() || isAdmin())) { + if (isAppOrAdminOnSameServer()) { server = proc.listen(ON.address(), ON.port()); } else { server = proc.listen(address(), port()); @@ -204,6 +208,10 @@ public synchronized Server listen() { return server; } + private boolean isAppOrAdminOnSameServer() { + return appAndAdminOnSameServer() && (isApp() || isAdmin()); + } + private boolean delegateAdminToApp() { return isAdminAndSameAsApp() && ON.server != null; } @@ -257,63 +265,63 @@ private synchronized void activate() { public OnRoute route(String verb, String path) { activate(); - return new OnRoute(http(), defaults, verb.toUpperCase(), path); + return new OnRoute(http(), defaults, routes, verb.toUpperCase(), path); } public OnRoute get(String path) { activate(); - return new OnRoute(http(), defaults, GET, path); + return new OnRoute(http(), defaults, routes, GET, path); } public OnRoute post(String path) { activate(); - return new OnRoute(http(), defaults, POST, path); + return new OnRoute(http(), defaults, routes, POST, path); } public OnRoute put(String path) { activate(); - return new OnRoute(http(), defaults, PUT, path); + return new OnRoute(http(), defaults, routes, PUT, path); } public OnRoute delete(String path) { activate(); - return new OnRoute(http(), defaults, DELETE, path); + return new OnRoute(http(), defaults, routes, DELETE, path); } public OnRoute patch(String path) { activate(); - return new OnRoute(http(), defaults, PATCH, path); + return new OnRoute(http(), defaults, routes, PATCH, path); } public OnRoute options(String path) { activate(); - return new OnRoute(http(), defaults, OPTIONS, path); + return new OnRoute(http(), defaults, routes, OPTIONS, path); } public OnRoute head(String path) { activate(); - return new OnRoute(http(), defaults, HEAD, path); + return new OnRoute(http(), defaults, routes, HEAD, path); } public OnRoute trace(String path) { activate(); - return new OnRoute(http(), defaults, TRACE, path); + return new OnRoute(http(), defaults, routes, TRACE, path); } public OnRoute page(String path) { activate(); - return new OnRoute(http(), defaults, GET_OR_POST, path); + return new OnRoute(http(), defaults, routes, GET_OR_POST, path); } public Setup req(ReqHandler handler) { activate(); - routes.addGenericHandler(new DelegatingParamsAwareReqHandler(http(), opts(), handler)); + routes.addGenericHandler(new DelegatingParamsAwareReqHandler(http(), routes, opts(), handler)); return this; } public Setup req(ReqRespHandler handler) { activate(); - routes.addGenericHandler(new DelegatingParamsAwareReqRespHandler(http(), opts(), handler)); + routes.addGenericHandler(new DelegatingParamsAwareReqRespHandler(http(), routes, opts(), handler)); return this; } diff --git a/rapidoid-integration-tests/src/test/java/org/rapidoid/httpfast/HttpHandlerTest.java b/rapidoid-integration-tests/src/test/java/org/rapidoid/httpfast/HttpHandlerTest.java index 5399c6991d..c7e981629b 100644 --- a/rapidoid-integration-tests/src/test/java/org/rapidoid/httpfast/HttpHandlerTest.java +++ b/rapidoid-integration-tests/src/test/java/org/rapidoid/httpfast/HttpHandlerTest.java @@ -28,6 +28,7 @@ import org.rapidoid.http.IntegrationTestCommons; import org.rapidoid.http.Req; import org.rapidoid.http.customize.Customization; +import org.rapidoid.http.impl.HttpRoutesImpl; import org.rapidoid.net.Server; import org.rapidoid.u.U; @@ -37,11 +38,13 @@ public class HttpHandlerTest extends IntegrationTestCommons { @Test public void testFastHttpHandler() { - FastHttp http = new FastHttp(new Customization("example", new Config(), new Config())); + Customization customization = new Customization("example", new Config(), new Config()); + HttpRoutesImpl routes = new HttpRoutesImpl(customization); + FastHttp http = new FastHttp(routes); - http.on("get", "/abc", Req::data); + routes.on("get", "/abc", Req::data); - http.on("get,post", "/xyz", req -> U.list(req.uri(), req.data())); + routes.on("get,post", "/xyz", req -> U.list(req.uri(), req.data())); Server server = http.listen(7779); diff --git a/rapidoid-standalone/src/main/java/org/rapidoid/standalone/Main.java b/rapidoid-standalone/src/main/java/org/rapidoid/standalone/Main.java index 9728a3d854..6c28d7476f 100644 --- a/rapidoid-standalone/src/main/java/org/rapidoid/standalone/Main.java +++ b/rapidoid-standalone/src/main/java/org/rapidoid/standalone/Main.java @@ -24,22 +24,23 @@ import org.rapidoid.annotation.Authors; import org.rapidoid.annotation.Since; import org.rapidoid.gui.reqinfo.ReqInfoUtils; +import org.rapidoid.http.HttpVerb; import org.rapidoid.http.Req; import org.rapidoid.http.ReqRespHandler; import org.rapidoid.http.Resp; +import org.rapidoid.setup.App; import org.rapidoid.setup.On; import org.rapidoid.u.U; -import org.rapidoid.web.Rapidoid; @Authors("Nikolche Mihajlovski") @Since("5.1.0") public class Main extends RapidoidThing { public static void main(String[] args) { - Rapidoid.run(args).full(); + App.bootstrap(args).jpa().adminCenter(); - if (On.setup().routes().allNonAdmin().isEmpty()) { - On.page("/").view("_welcome").mvc(new ReqRespHandler() { + if (!On.setup().routes().hasRouteOrResource(HttpVerb.GET, "/")) { + On.get("/").view("_welcome").mvc(new ReqRespHandler() { @Override public Object execute(Req req, Resp resp) throws Exception { return U.map("adminUrl", ReqInfoUtils.adminUrl()); diff --git a/rapidoid-test-commons/src/main/java/org/rapidoid/test/TestCommons.java b/rapidoid-test-commons/src/main/java/org/rapidoid/test/TestCommons.java index 19b3e41db8..14b131a0dc 100644 --- a/rapidoid-test-commons/src/main/java/org/rapidoid/test/TestCommons.java +++ b/rapidoid-test-commons/src/main/java/org/rapidoid/test/TestCommons.java @@ -88,7 +88,7 @@ public void checkForErrors() { } } - protected void registerError(AssertionError e) { + protected void registerError(Throwable e) { hasError = true; e.printStackTrace(); } diff --git a/rapidoid-web/src/test/java/org/rapidoid/http/MicroServicesTest.java b/rapidoid-web/src/test/java/org/rapidoid/http/MicroServicesTest.java index d63e3e7cb7..ecc11253d5 100644 --- a/rapidoid-web/src/test/java/org/rapidoid/http/MicroServicesTest.java +++ b/rapidoid-web/src/test/java/org/rapidoid/http/MicroServicesTest.java @@ -48,7 +48,7 @@ public Object execute(Req req) throws Exception { eq(REST.get("http://localhost:8888/?n=7", Integer.class).intValue(), 8); eq(REST.post("http://localhost:8888/?n=7", Integer.class).intValue(), 8); - int count = 10000; + int count = 1000; final CountDownLatch latch = new CountDownLatch(count); Msc.startMeasure(); @@ -69,7 +69,7 @@ public void onDone(Integer result, Throwable error) throws Exception { if (result != null) { eq(result.intValue(), expected); } else { - System.out.println(error); + registerError(error); } latch.countDown(); }