All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.vertx.ext.web.impl.RoutingContextImpl Maven / Gradle / Ivy
/*
* Copyright 2014 Red Hat, Inc.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Apache License v2.0 which accompanies this distribution.
*
* The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* The Apache License v2.0 is available at
* http://www.opensource.org/licenses/apache2.0.php
*
* You may elect to redistribute this code under either of these licenses.
*/
package io.vertx.ext.web.impl;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.QueryStringDecoder;
import io.vertx.codegen.annotations.Nullable;
import io.vertx.core.*;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.*;
import io.vertx.core.http.impl.HttpUtils;
import io.vertx.core.impl.ContextInternal;
import io.vertx.ext.auth.User;
import io.vertx.ext.web.RequestBody;
import io.vertx.ext.web.FileUpload;
import io.vertx.ext.web.RoutingContext;
import io.vertx.ext.web.Session;
import io.vertx.ext.web.handler.HttpException;
import io.vertx.ext.web.handler.impl.UserHolder;
import java.nio.charset.Charset;
import java.util.*;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import static io.vertx.ext.web.handler.impl.SessionHandlerImpl.SESSION_USER_HOLDER_KEY;
/**
* @author Tim Fox
*/
public class RoutingContextImpl extends RoutingContextImplBase {
private static final AtomicIntegerFieldUpdater HANDLER_SEQ =
AtomicIntegerFieldUpdater.newUpdater(RoutingContextImpl.class, "handlerSeq");
private final RouterImpl router;
private final HttpServerRequest request;
private final RequestBodyImpl body;
private volatile int handlerSeq;
private Map data;
private Map pathParams;
private MultiMap queryParams;
private SparseArray> headersEndHandlers;
private SparseArray> bodyEndHandlers;
// clean up handlers
private SparseArray>> endHandlers;
private Throwable failure;
private int statusCode = -1;
private String normalizedPath;
private String acceptableContentType;
private ParsableHeaderValuesContainer parsedHeaders;
private List fileUploads;
private Session session;
private User user;
private volatile boolean isSessionAccessed = false;
private volatile boolean endHandlerCalled = false;
public RoutingContextImpl(String mountPoint, RouterImpl router, HttpServerRequest request, Set routes) {
super(mountPoint, routes, router);
this.router = router;
this.request = new HttpServerRequestWrapper(request, router.getAllowForward());
this.body = new RequestBodyImpl(this);
final String path = request.path();
if (path == null || path.length() == 0) {
// HTTP paths must start with a '/'
fail(400);
} else if (path.charAt(0) != '/') {
// For compatiblity we return `Not Found` when a path does not start with `/`
fail(404);
}
}
private String ensureNotNull(String string){
return string == null ? "" : string;
}
private void fillParsedHeaders(HttpServerRequest request) {
String accept = request.getHeader(HttpHeaders.ACCEPT);
String acceptCharset = request.getHeader (HttpHeaders.ACCEPT_CHARSET);
String acceptEncoding = request.getHeader(HttpHeaders.ACCEPT_ENCODING);
String acceptLanguage = request.getHeader(HttpHeaders.ACCEPT_LANGUAGE);
String contentType = ensureNotNull(request.getHeader(HttpHeaders.CONTENT_TYPE));
parsedHeaders = new ParsableHeaderValuesContainer(
HeaderParser.sort(HeaderParser.convertToParsedHeaderValues(accept, ParsableMIMEValue::new)),
HeaderParser.sort(HeaderParser.convertToParsedHeaderValues(acceptCharset, ParsableHeaderValue::new)),
HeaderParser.sort(HeaderParser.convertToParsedHeaderValues(acceptEncoding, ParsableHeaderValue::new)),
HeaderParser.sort(HeaderParser.convertToParsedHeaderValues(acceptLanguage, ParsableLanguageValue::new)),
new ParsableMIMEValue(contentType)
);
}
@Override
public HttpServerRequest request() {
return request;
}
@Override
public HttpServerResponse response() {
return request.response();
}
@Override
public Throwable failure() {
return failure;
}
@Override
public int statusCode() {
return statusCode;
}
@Override
public boolean failed() {
return failure != null || statusCode != -1;
}
@Override
public void next() {
if (!iterateNext()) {
checkHandleNoMatch();
}
}
private void checkHandleNoMatch() {
// Next called but no more matching routes
if (failed()) {
// Send back FAILURE
unhandledFailure(statusCode, failure, router);
} else {
Handler handler = router.getErrorHandlerByStatusCode(this.matchFailure);
this.statusCode = this.matchFailure;
if (handler == null) { // Default 404 handling
// Send back empty default response with status code
this.response().setStatusCode(matchFailure);
if (this.request().method() != HttpMethod.HEAD && matchFailure == 404) {
// If it's a 404 let's send a body too
this.response()
.putHeader(HttpHeaderNames.CONTENT_TYPE, "text/html; charset=utf-8")
.end(DEFAULT_404);
} else {
this.response().end();
}
} else {
handler.handle(this);
}
}
}
@Override
public void fail(int statusCode) {
this.statusCode = statusCode;
doFail();
}
@Override
public void fail(Throwable t) {
if (t instanceof HttpException) {
this.fail(((HttpException) t).getStatusCode(), t);
} else {
this.fail(500, t);
}
}
@Override
public void fail(int statusCode, Throwable throwable) {
this.statusCode = statusCode;
this.failure = throwable == null ? new NullPointerException() : throwable;
if (LOG.isDebugEnabled()) {
LOG.debug("RoutingContext failure (" + statusCode + ")", failure);
}
doFail();
}
@Override
public RoutingContext put(String key, Object obj) {
getData().put(key, obj);
return this;
}
@Override
public Vertx vertx() {
return router.vertx();
}
@Override
public @Nullable RoutingContextInternal parent() {
return null;
}
@Override
@SuppressWarnings("unchecked")
public T get(String key) {
if (data == null) {
return null;
} else {
return (T) getData().get(key);
}
}
@Override
@SuppressWarnings("unchecked")
public T get(String key, T defaultValue) {
if (data == null) {
return defaultValue;
} else {
Map data = getData();
if (data.containsKey(key)) {
return (T) data.get(key);
} else {
return defaultValue;
}
}
}
@Override
@SuppressWarnings("unchecked")
public T remove(String key) {
if (data == null) {
return null;
} else {
return (T) getData().remove(key);
}
}
@Override
public Map data() {
return getData();
}
@Override
public String normalizedPath() {
if (normalizedPath == null) {
String path = request.path();
if (path == null) {
normalizedPath = "/";
} else {
normalizedPath = HttpUtils.normalizePath(path);
}
}
return normalizedPath;
}
@Override
@Deprecated
public Cookie getCookie(String name) {
return request.getCookie(name);
}
@Override
@Deprecated
public RoutingContext addCookie(io.vertx.core.http.Cookie cookie) {
request.response().addCookie(cookie);
return this;
}
@Override
@Deprecated
public Cookie removeCookie(String name, boolean invalidate) {
return request.response().removeCookie(name, invalidate);
}
@Override
@Deprecated
public int cookieCount() {
return request.cookieCount();
}
@Override
@Deprecated
public Map cookieMap() {
return request.cookieMap();
}
@Override
public RequestBody body() {
return body;
}
@Override
public void setBody(Buffer body) {
this.body.setBuffer(body);
}
@Override
public List fileUploads() {
if (fileUploads == null) {
fileUploads = new ArrayList<>();
}
return fileUploads;
}
@Override
public void setSession(Session session) {
this.session = session;
// attempt to load the user from the session if one exists
UserHolder holder = session.get(SESSION_USER_HOLDER_KEY);
if (holder != null) {
holder.refresh(this);
}
}
@Override
public Session session() {
this.isSessionAccessed = true;
return session;
}
@Override
public boolean isSessionAccessed(){
return isSessionAccessed;
}
@Override
public User user() {
return user;
}
@Override
public void setUser(User user) {
this.user = user;
}
@Override
public void clearUser() {
this.user = null;
}
@Override
public String getAcceptableContentType() {
return acceptableContentType;
}
@Override
public void setAcceptableContentType(String contentType) {
this.acceptableContentType = contentType;
}
@Override
public ParsableHeaderValuesContainer parsedHeaders() {
if (parsedHeaders == null) {
fillParsedHeaders(request);
}
return parsedHeaders;
}
@Override
public int addHeadersEndHandler(Handler handler) {
int seq = nextHandlerSeq();
getHeadersEndHandlers().put(seq, handler);
return seq;
}
@Override
public boolean removeHeadersEndHandler(int handlerID) {
return getHeadersEndHandlers().remove(handlerID) != null;
}
@Override
public int addBodyEndHandler(Handler handler) {
int seq = nextHandlerSeq();
getBodyEndHandlers().put(seq, handler);
return seq;
}
@Override
public boolean removeBodyEndHandler(int handlerID) {
return getBodyEndHandlers().remove(handlerID) != null;
}
@Override
public int addEndHandler(Handler> handler) {
int seq = nextHandlerSeq();
getEndHandlers().put(seq, handler);
return seq;
}
@Override
public boolean removeEndHandler(int handlerID) {
return getEndHandlers().remove(handlerID) != null;
}
@Override
public void reroute(HttpMethod method, String path) {
if (path.charAt(0) != '/') {
throw new IllegalArgumentException("path must start with '/'");
}
// change the method and path of the request
((HttpServerRequestWrapper) request).changeTo(method, path);
// we need to reset the normalized path
normalizedPath = null;
// we also need to reset any previous status
statusCode = -1;
// we need to reset any response headers
response().headers().clear();
// reset the end handlers
if (headersEndHandlers != null) {
headersEndHandlers.clear();
}
if (bodyEndHandlers != null) {
bodyEndHandlers.clear();
}
failure = null;
restart();
}
@Override
public Map pathParams() {
return getPathParams();
}
@Override
public @Nullable String pathParam(String name) {
return getPathParams().get(name);
}
@Override
public MultiMap queryParams() {
return getQueryParams(null);
}
@Override
public MultiMap queryParams(Charset charset) {
return getQueryParams(charset);
}
@Override
public @Nullable List queryParam(String query) {
return queryParams().getAll(query);
}
private MultiMap getQueryParams(Charset charset) {
// Check if query params are already parsed
if (charset != null || queryParams == null) {
try {
// Decode query parameters and put inside context.queryParams
if (charset == null) {
queryParams = MultiMap.caseInsensitiveMultiMap();
Map> decodedParams = new QueryStringDecoder(request.uri()).parameters();
for (Map.Entry> entry : decodedParams.entrySet()) {
queryParams.add(entry.getKey(), entry.getValue());
}
} else {
MultiMap queryParams = MultiMap.caseInsensitiveMultiMap();
Map> decodedParams = new QueryStringDecoder(request.uri(), charset).parameters();
for (Map.Entry> entry : decodedParams.entrySet()) {
queryParams.add(entry.getKey(), entry.getValue());
}
return queryParams;
}
} catch (IllegalArgumentException e) {
throw new HttpException(400, "Error while decoding query params", e);
}
}
return queryParams;
}
private Map getPathParams() {
if (pathParams == null) {
pathParams = new HashMap<>();
}
return pathParams;
}
private SparseArray> getHeadersEndHandlers() {
if (headersEndHandlers == null) {
headersEndHandlers = new SparseArray<>();
// order is important we we should traverse backwards
response().headersEndHandler(v -> headersEndHandlers.forEachInReverseOrder(handler -> handler.handle(null)));
}
return headersEndHandlers;
}
private SparseArray> getBodyEndHandlers() {
if (bodyEndHandlers == null) {
bodyEndHandlers = new SparseArray<>();
// order is important we we should traverse backwards
response().bodyEndHandler(v -> bodyEndHandlers.forEachInReverseOrder(handler -> handler.handle(null)));
}
return bodyEndHandlers;
}
private SparseArray>> getEndHandlers() {
if (endHandlers == null) {
// order is important as we should traverse backwards
endHandlers = new SparseArray<>();
final ContextInternal ctx = (ContextInternal) vertx().getOrCreateContext();
final Handler endHandler = v -> {
if (!endHandlerCalled) {
endHandlerCalled = true;
endHandlers.forEachInReverseOrder(handler -> handler.handle(ctx.succeededFuture()));
}
};
final Handler exceptionHandler = cause -> {
if (!endHandlerCalled) {
endHandlerCalled = true;
endHandlers.forEachInReverseOrder(handler -> handler.handle(ctx.failedFuture(cause)));
}
};
final Handler closeHandler = cause -> {
if (!endHandlerCalled) {
endHandlerCalled = true;
endHandlers.forEachInReverseOrder(handler -> handler.handle(ctx.failedFuture("Connection closed")));
}
};
response()
.endHandler(endHandler)
.exceptionHandler(exceptionHandler)
.closeHandler(closeHandler);
}
return endHandlers;
}
private void doFail() {
this.iter = router.iterator();
currentRoute = null;
next();
}
private Map getData() {
if (data == null) {
data = new HashMap<>();
}
return data;
}
private int nextHandlerSeq() {
int seq = HANDLER_SEQ.incrementAndGet(this);
if (seq == Integer.MAX_VALUE) {
throw new IllegalStateException("Too many header/body end handlers!");
}
return seq;
}
private static final String DEFAULT_404 =
"Resource not found ";
}
