net.officefloor.web.HttpRouteSectionSource Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of officeweb Show documentation
Show all versions of officeweb Show documentation
OfficeFloor plug-in for Web
/*
* OfficeFloor - http://www.officefloor.net
* Copyright (C) 2005-2018 Daniel Sagenschneider
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see null.
*/
private HttpEscalationHandler escalationHandler = null;
/**
* Optional {@link Interception}.
*/
private Interception interception = null;
/**
* {@link RouteInput} instances.
*/
private final List routes = new LinkedList<>();
/**
* {@link Redirect} instances.
*/
private final List redirects = new LinkedList<>();
/**
* Instantiate.
*
* @param contextPath
* Context path. May be null.
*/
public HttpRouteSectionSource(String contextPath) {
this.builder = new WebRouterBuilder(contextPath);
}
/**
* Specifies the {@link HttpEscalationHandler}
*
* @param escalationHandler
* {@link HttpEscalationHandler}. May be null.
*/
public void setHttpEscalationHandler(HttpEscalationHandler escalationHandler) {
this.escalationHandler = escalationHandler;
}
/**
* Obtains the {@link Interception}.
*
* @return {@link Interception}.
*/
public Interception getInterception() {
if (this.interception == null) {
this.interception = new Interception("INTERCEPTION_OUT", "INTERCEPTION_IN");
}
return this.interception;
}
/**
* Indicates if the path contains parameters.
*
* @param path
* Path.
* @return true should the path contain parameters.
*/
public boolean isPathParameters(String path) {
return WebRouterBuilder.isPathParameters(path);
}
/**
* Adds a route.
*
* @param isSecure
* Indicates if a secure connection is required for the route.
* @param method
* {@link HttpMethod}.
* @param path
* Route path.
* @return {@link RouteInput} for the route.
*/
public RouteInput addRoute(boolean isSecure, HttpMethod method, String path) {
// Obtain the flow index for the route
int flowIndex = this.routes.size();
// Add the route
HttpInputPath inputPath = this.builder.addRoute(method, path, new WebRouteHandlerImpl(isSecure, flowIndex));
// Track route information for configuration
RouteInput input = new RouteInput(flowIndex, method, path, inputPath);
this.routes.add(input);
// Return the route input
return input;
}
/**
* Adds a {@link Redirect}.
*
* @param isSecure
* Indicates to redirect to a secure port.
* @param routeInput
* {@link RouteInput} to redirect to.
* @param parameterType
* Type of parameter passed to the redirect {@link ManagedFunction}
* to source values for constructing the path. May be
* null.
* @return {@link Redirect}.
* @throws Exception
* If fails to add the redirect.
*/
public Redirect addRedirect(boolean isSecure, RouteInput routeInput, Class parameterType) throws Exception {
// Obtain the redirect index (to keep name unique)
int redirectIndex = this.redirects.size();
// Create the HTTP path factory (defaulting type to object)
parameterType = (parameterType == null) ? Object.class : parameterType;
HttpPathFactory httpPathFactory = routeInput.inputPath.createHttpPathFactory(parameterType);
// Create the redirect input name
String inputName = "REDIRECT_" + redirectIndex + (isSecure ? "_SECURE_" : "_") + routeInput.path
+ (parameterType == null ? "" : "_" + parameterType.getName());
// Create and register the redirect
Redirect redirect = new Redirect(isSecure, httpPathFactory, inputName);
this.redirects.add(redirect);
// Return the redirect
return redirect;
}
/*
* ==================== SectionSource ========================
*/
@Override
protected void loadSpecification(SpecificationContext context) {
}
@Override
public void sourceSection(SectionDesigner designer, SectionSourceContext context) throws Exception {
// All routes added via office, so now build web router
WebRouter webRouter = this.builder.build();
int nonHandledFlowIndex = this.routes.size();
HttpRouter httpRouter = new HttpRouter(webRouter, nonHandledFlowIndex);
// Add the routing function
SectionFunctionNamespace routeNamespace = designer.addSectionFunctionNamespace("ROUTE",
new HttpRouteManagedFunctionSource(httpRouter));
SectionFunction route = routeNamespace.addSectionFunction(WebArchitect.HANDLER_INPUT_NAME, ROUTE_FUNCTION_NAME);
// Add the handle redirect function
SectionFunctionNamespace handleRedirectNamespace = designer.addSectionFunctionNamespace("REDIRECT",
new HttpHandleRedirectFunctionSource(httpRouter));
SectionFunction handleRedirect = handleRedirectNamespace.addSectionFunction(HANDLE_REDIRECT_FUNCTION_NAME,
HANDLE_REDIRECT_FUNCTION_NAME);
// Link redirect flow to handle redirect
designer.link(route.getFunctionFlow(HANDLE_REDIRECT_FLOW), handleRedirect, false);
// Determine if interception
SectionInput handleHttpInput = designer.addSectionInput(WebArchitect.HANDLER_INPUT_NAME, null);
if (this.interception == null) {
// No interception, make routing function handle HTTP input
designer.link(handleHttpInput, route);
} else {
// Have interception, so provide hooks to intercept
SectionFunctionNamespace interceptNamespace = designer.addSectionFunctionNamespace(
InterceptManagedFunctionSource.FUNCTION_NAME, new InterceptManagedFunctionSource());
SectionFunction intercept = interceptNamespace.addSectionFunction(
InterceptManagedFunctionSource.FUNCTION_NAME, InterceptManagedFunctionSource.FUNCTION_NAME);
designer.link(handleHttpInput, intercept);
// Trigger interception
SectionOutput interceptOutput = designer.addSectionOutput(this.interception.outputName, null, false);
designer.link(intercept, interceptOutput);
// After interception, let routing service
SectionInput routeInput = designer.addSectionInput(this.interception.inputName, null);
designer.link(routeInput, route);
}
// Obtain the connection, request state, session and application state
SectionObject serverHttpConnection = designer.addSectionObject(ServerHttpConnection.class.getSimpleName(),
ServerHttpConnection.class.getName());
SectionObject requestState = designer.addSectionObject(HttpRequestState.class.getSimpleName(),
HttpRequestState.class.getName());
SectionObject session = designer.addSectionObject(HttpSession.class.getSimpleName(),
HttpSession.class.getName());
// Link the routing to section outputs
for (RouteInput routeConfig : this.routes) {
// Obtain the route flow
String outputName = routeConfig.getOutputName();
SectionOutput output = designer.addSectionOutput(outputName, null, false);
// Obtain the handle redirect flow (never initialises)
FunctionFlow handleRedirectFlow = handleRedirect.getFunctionFlow(outputName);
designer.link(handleRedirectFlow, output, false);
// Determine if path parameters
FunctionFlow routeFlow = route.getFunctionFlow(outputName);
if (!routeConfig.inputPath.isPathParameters()) {
// No path parameters, so link directly
designer.link(routeFlow, output, false);
} else {
// Path parameters, so must load to request state
SectionFunctionNamespace initialiseNamespace = designer.addSectionFunctionNamespace(outputName,
new InitialiseHttpRequestStateManagedFunctionSource());
SectionFunction initialise = initialiseNamespace.addSectionFunction(outputName,
INITIALISE_REQUEST_STATE_FUNCTION_NAME);
designer.link(routeFlow, initialise, false);
// Configure HTTP path arguments parameter
initialise.getFunctionObject(InitialiseHttpRequestStateDependencies.PATH_ARGUMENTS.name())
.flagAsParameter();
// Configure dependency on request state
designer.link(
initialise.getFunctionObject(InitialiseHttpRequestStateDependencies.HTTP_REQUEST_STATE.name()),
requestState);
// Link initialise to output
designer.link(initialise, output);
}
}
// Link non-handled to output
SectionOutput unhandled = designer.addSectionOutput(UNHANDLED_OUTPUT_NAME, null, false);
designer.link(route.getFunctionFlow(UNHANDLED_OUTPUT_NAME), unhandled, false);
designer.link(handleRedirect.getFunctionFlow(UNHANDLED_OUTPUT_NAME), unhandled, false);
// Configure the not found input
SectionInput notFoundInput = designer.addSectionInput(NOT_FOUND_INPUT_NAME, null);
SectionFunctionNamespace notFoundNamespace = designer.addSectionFunctionNamespace("NOT_FOUND",
new NotFoundManagedFunctionSource());
SectionFunction notFound = notFoundNamespace.addSectionFunction(NOT_FOUND_INPUT_NAME, NOT_FOUND_INPUT_NAME);
designer.link(notFoundInput, notFound);
// Escalate not found to office
SectionOutput notFoundEscalation = designer.addSectionOutput(NotFoundHttpException.class.getSimpleName(),
NotFoundHttpException.class.getName(), true);
designer.link(notFound.getFunctionEscalation(NotFoundHttpException.class.getName()), notFoundEscalation, true);
// Configure routing dependencies
designer.link(route.getFunctionObject(HttpRouteDependencies.SERVER_HTTP_CONNECTION.name()),
serverHttpConnection);
// Configure handle redirect dependencies
handleRedirect.getFunctionObject(HttpHandleRedirectDependencies.COOKIE.name()).flagAsParameter();
designer.link(handleRedirect.getFunctionObject(HttpHandleRedirectDependencies.SERVER_HTTP_CONNECTION.name()),
serverHttpConnection);
designer.link(handleRedirect.getFunctionObject(HttpHandleRedirectDependencies.REQUEST_STATE.name()),
requestState);
designer.link(handleRedirect.getFunctionObject(HttpHandleRedirectDependencies.SESSION.name()), session);
// Configure not found dependencies
designer.link(notFound.getFunctionObject(NotFoundDependencies.SERVER_HTTP_CONNECTION.name()),
serverHttpConnection);
// Configure the redirects
for (Redirect redirect : this.redirects) {
// Obtain the function name
String functionName = redirect.inputName;
// Add the function to send the redirect
SectionFunctionNamespace redirectNamespace = designer.addSectionFunctionNamespace(functionName,
new RedirectManagedFunctionSource(redirect));
SectionFunction redirection = redirectNamespace.addSectionFunction(functionName, functionName);
// Link input to the function
SectionInput redirectInput = designer.addSectionInput(functionName, null);
designer.link(redirectInput, redirection);
// Configure dependency on server HTTP connection
redirection.getFunctionObject(HttpRedirectDependencies.PATH_VALUES.name()).flagAsParameter();
designer.link(redirection.getFunctionObject(HttpRedirectDependencies.SERVER_HTTP_CONNECTION.name()),
serverHttpConnection);
designer.link(redirection.getFunctionObject(HttpRedirectDependencies.REQUEST_STATE.name()), requestState);
designer.link(redirection.getFunctionObject(HttpRedirectDependencies.SESSION_STATE.name()), session);
}
}
/**
* {@link ManagedFunctionSource} for the {@link InterceptFunction}.
*/
@PrivateSource
private static class InterceptManagedFunctionSource extends AbstractManagedFunctionSource {
/**
* Name of the {@link ManagedFunction}.
*/
private static final String FUNCTION_NAME = "INTERCEPT";
/*
* ============ ManagedFunctionSource ==============
*/
@Override
protected void loadSpecification(SpecificationContext context) {
}
@Override
public void sourceManagedFunctions(FunctionNamespaceBuilder functionNamespaceTypeBuilder,
ManagedFunctionSourceContext context) throws Exception {
// Add the intercept function
functionNamespaceTypeBuilder.addManagedFunctionType(FUNCTION_NAME, new InterceptFunction(), None.class,
None.class);
}
}
/**
* {@link ManagedFunctionSource} for the {@link HttpRouteFunction}.
*/
@PrivateSource
private class HttpRouteManagedFunctionSource extends AbstractManagedFunctionSource {
/**
* {@link HttpRouter}.
*/
private final HttpRouter router;
/**
* Instantiate.
*
* @param router
* {@link HttpRouter}.
*/
private HttpRouteManagedFunctionSource(HttpRouter router) {
this.router = router;
}
/*
* ============ ManagedFunctionSource ==============
*/
@Override
protected void loadSpecification(SpecificationContext context) {
}
@Override
public void sourceManagedFunctions(FunctionNamespaceBuilder functionNamespaceTypeBuilder,
ManagedFunctionSourceContext context) throws Exception {
// Obtain the routes
List routes = HttpRouteSectionSource.this.routes;
// Obtain the handle redirect flow (size is non-handled flow)
int handleRedirectFlowIndex = routes.size() + 1;
// Build the function
ManagedFunctionTypeBuilder builder = functionNamespaceTypeBuilder
.addManagedFunctionType(ROUTE_FUNCTION_NAME,
new HttpRouteFunction(HttpRouteSectionSource.this.escalationHandler,
handleRedirectFlowIndex, this.router),
HttpRouteDependencies.class, Indexed.class);
// Configure the flows for the routes
this.router.configureRoutes(routes, builder);
// Add handle redirect flow
builder.addFlow().setLabel(HANDLE_REDIRECT_FLOW);
// Configure dependency on server HTTP connection
builder.addObject(ServerHttpConnection.class).setKey(HttpRouteDependencies.SERVER_HTTP_CONNECTION);
}
}
/**
* {@link ManagedFunctionSource} for the {@link HttpHandleRedirectFunction}.
*/
@PrivateSource
private class HttpHandleRedirectFunctionSource extends AbstractManagedFunctionSource {
/**
* {@link HttpRouter}.
*/
private final HttpRouter router;
/**
* Instantiate.
*
* @param router
* {@link HttpRouter}.
*/
private HttpHandleRedirectFunctionSource(HttpRouter router) {
this.router = router;
}
/*
* ============ ManagedFunctionSource ==============
*/
@Override
protected void loadSpecification(SpecificationContext context) {
}
@Override
public void sourceManagedFunctions(FunctionNamespaceBuilder functionNamespaceTypeBuilder,
ManagedFunctionSourceContext context) throws Exception {
// Obtain the routes
List routes = HttpRouteSectionSource.this.routes;
// Build the function
ManagedFunctionTypeBuilder builder = functionNamespaceTypeBuilder
.addManagedFunctionType(HANDLE_REDIRECT_FUNCTION_NAME, new HttpHandleRedirectFunction(this.router),
HttpHandleRedirectDependencies.class, Indexed.class);
// Configure the flows for the routes
this.router.configureRoutes(routes, builder);
// Configure dependency on server HTTP connection
builder.addObject(HttpRequestCookie.class).setKey(HttpHandleRedirectDependencies.COOKIE);
builder.addObject(ServerHttpConnection.class).setKey(HttpHandleRedirectDependencies.SERVER_HTTP_CONNECTION);
builder.addObject(HttpRequestState.class).setKey(HttpHandleRedirectDependencies.REQUEST_STATE);
builder.addObject(HttpSession.class).setKey(HttpHandleRedirectDependencies.SESSION);
}
}
/**
* {@link ManagedFunctionSource} for the
* {@link InitialiseHttpRequestStateFunction}.
*/
@PrivateSource
private class InitialiseHttpRequestStateManagedFunctionSource extends AbstractManagedFunctionSource {
/*
* ============ ManagedFunctionSource ==============
*/
@Override
protected void loadSpecification(SpecificationContext context) {
}
@Override
public void sourceManagedFunctions(FunctionNamespaceBuilder functionNamespaceTypeBuilder,
ManagedFunctionSourceContext context) throws Exception {
// Add the initialise HTTP request state function
ManagedFunctionTypeBuilder builder = functionNamespaceTypeBuilder
.addManagedFunctionType(INITIALISE_REQUEST_STATE_FUNCTION_NAME,
new InitialiseHttpRequestStateFunction(), InitialiseHttpRequestStateDependencies.class,
None.class);
// Configure dependency on the request state and path arguments
builder.addObject(HttpArgument.class).setKey(InitialiseHttpRequestStateDependencies.PATH_ARGUMENTS);
builder.addObject(HttpRequestState.class).setKey(InitialiseHttpRequestStateDependencies.HTTP_REQUEST_STATE);
}
}
/**
* {@link ManagedFunctionSource} for the {@link HttpRedirectFunction}.
*/
@PrivateSource
private class RedirectManagedFunctionSource extends AbstractManagedFunctionSource {
/**
* {@link Redirect}.
*/
private final Redirect redirect;
/**
* Instantiate.
*
* @param redirect
* {@link Redirect}.
*/
private RedirectManagedFunctionSource(Redirect redirect) {
this.redirect = redirect;
}
/*
* ============ ManagedFunctionSource ==============
*/
@Override
protected void loadSpecification(SpecificationContext context) {
}
@Override
public void sourceManagedFunctions(FunctionNamespaceBuilder functionNamespaceTypeBuilder,
ManagedFunctionSourceContext context) throws Exception {
// Create the function and obtain it's name
final String functionName = this.redirect.inputName;
HttpRedirectFunction function = new HttpRedirectFunction<>(this.redirect.isSecure,
this.redirect.httpPathFactory);
// Add the redirect function
ManagedFunctionTypeBuilder builder = functionNamespaceTypeBuilder
.addManagedFunctionType(functionName, function, HttpRedirectDependencies.class, None.class);
// Configure dependencies
builder.addObject(this.redirect.httpPathFactory.getValuesType())
.setKey(HttpRedirectDependencies.PATH_VALUES);
builder.addObject(ServerHttpConnection.class).setKey(HttpRedirectDependencies.SERVER_HTTP_CONNECTION);
builder.addObject(HttpRequestState.class).setKey(HttpRedirectDependencies.REQUEST_STATE);
builder.addObject(HttpSession.class).setKey(HttpRedirectDependencies.SESSION_STATE);
}
}
/**
* {@link ManagedFunctionSource} for the {@link NotFoundFunction}.
*/
@PrivateSource
private class NotFoundManagedFunctionSource extends AbstractManagedFunctionSource {
/*
* ============ ManagedFunctionSource ==============
*/
@Override
protected void loadSpecification(SpecificationContext context) {
}
@Override
public void sourceManagedFunctions(FunctionNamespaceBuilder functionNamespaceTypeBuilder,
ManagedFunctionSourceContext context) throws Exception {
// Add the not found function
ManagedFunctionTypeBuilder builder = functionNamespaceTypeBuilder
.addManagedFunctionType(NOT_FOUND_INPUT_NAME, new NotFoundFunction(), NotFoundDependencies.class,
None.class);
// Configure dependency on server HTTP connection
builder.addObject(ServerHttpConnection.class).setKey(NotFoundDependencies.SERVER_HTTP_CONNECTION);
// Configure not found escalation
builder.addEscalation(NotFoundHttpException.class);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy