@Override
public boolean equals(Object o) {
if (!(o instanceof HttpMethod)) {
return false;
}
HttpMethod that = (HttpMethod) o;
return name().equals(that.name());
}
@Override
protected boolean isContentAlwaysEmpty(HttpMessage msg) {
final int statusCode = ((HttpResponse) msg).getStatus().code();
if (statusCode == 100) {
// 100-continue response should be excluded from paired comparison.
return true;
}
// Get the getMethod of the HTTP request that corresponds to the
// current response.
HttpMethod method = queue.poll();
char firstChar = method.name().charAt(0);
switch (firstChar) {
case 'H':
// According to 4.3, RFC2616:
// All responses to the HEAD request getMethod MUST NOT include a
// message-body, even though the presence of entity-header fields
// might lead one to believe they do.
if (HttpMethod.HEAD.equals(method)) {
return true;
// The following code was inserted to work around the servers
// that behave incorrectly. It has been commented out
// because it does not work with well behaving servers.
// Please note, even if the 'Transfer-Encoding: chunked'
// header exists in the HEAD response, the response should
// have absolutely no content.
//
//// Interesting edge case:
//// Some poorly implemented servers will send a zero-byte
//// chunk if Transfer-Encoding of the response is 'chunked'.
////
//// return !msg.isChunked();
}
break;
case 'C':
// Successful CONNECT request results in a response with empty body.
if (statusCode == 200) {
if (HttpMethod.CONNECT.equals(method)) {
// Proxy connection established - Not HTTP anymore.
done = true;
queue.clear();
return true;
}
}
break;
}
return super.isContentAlwaysEmpty(msg);
}
static {
methodMap.put(OPTIONS.toString(), OPTIONS);
methodMap.put(GET.toString(), GET);
methodMap.put(HEAD.toString(), HEAD);
methodMap.put(POST.toString(), POST);
methodMap.put(PUT.toString(), PUT);
methodMap.put(PATCH.toString(), PATCH);
methodMap.put(DELETE.toString(), DELETE);
methodMap.put(TRACE.toString(), TRACE);
methodMap.put(CONNECT.toString(), CONNECT);
}
/** Returns visualized routing rules. */
@Override
public String toString() {
// Step 1/2: Dump routers and anyMethodRouter in order
final int numRoutes = size();
final List<String> methods = new ArrayList<String>(numRoutes);
final List<String> paths = new ArrayList<String>(numRoutes);
final List<String> targets = new ArrayList<String>(numRoutes);
// For router
for (Entry<HttpMethod, MethodlessRouter<T>> e : routers.entrySet()) {
HttpMethod method = e.getKey();
MethodlessRouter<T> router = e.getValue();
aggregateRoutes(method.toString(), router.first().routes(), methods, paths, targets);
aggregateRoutes(method.toString(), router.other().routes(), methods, paths, targets);
aggregateRoutes(method.toString(), router.last().routes(), methods, paths, targets);
}
// For anyMethodRouter
aggregateRoutes("*", anyMethodRouter.first().routes(), methods, paths, targets);
aggregateRoutes("*", anyMethodRouter.other().routes(), methods, paths, targets);
aggregateRoutes("*", anyMethodRouter.last().routes(), methods, paths, targets);
// For notFound
if (notFound != null) {
methods.add("*");
paths.add("*");
targets.add(targetToString(notFound));
}
// Step 2/2: Format the List into aligned columns: <method> <path> <target>
int maxLengthMethod = maxLength(methods);
int maxLengthPath = maxLength(paths);
String format = "%-" + maxLengthMethod + "s %-" + maxLengthPath + "s %s\n";
int initialCapacity = (maxLengthMethod + 1 + maxLengthPath + 1 + 20) * methods.size();
StringBuilder b = new StringBuilder(initialCapacity);
for (int i = 0; i < methods.size(); i++) {
String method = methods.get(i);
String path = paths.get(i);
String target = targets.get(i);
b.append(String.format(format, method, path, target));
}
return b.toString();
}
private HandlingResult invoke(
Handler handler, Registry registry, DefaultHandlingResult.ResultsHolder results)
throws HandlerTimeoutException {
ServerConfig serverConfig = registry.get(ServerConfig.class);
DefaultRequest request =
new DefaultRequest(
Instant.now(),
requestHeaders,
HttpMethod.valueOf(method.toUpperCase()),
HttpVersion.valueOf(protocol),
uri,
new InetSocketAddress(remoteHostAndPort.getHostText(), remoteHostAndPort.getPort()),
new InetSocketAddress(localHostAndPort.getHostText(), localHostAndPort.getPort()),
serverConfig,
new RequestBodyReader() {
@Override
public Promise<? extends ByteBuf> read(long maxContentLength, Block onTooLarge) {
return Promise.value(requestBody)
.route(r -> r.readableBytes() > maxContentLength, onTooLarge.action());
}
@Override
public TransformablePublisher<? extends ByteBuf> readStream(long maxContentLength) {
return Streams.<ByteBuf>yield(
r -> {
if (r.getRequestNum() > 0) {
return null;
} else {
return requestBody;
}
});
}
});
if (pathBinding != null) {
handler =
Handlers.chain(
ctx -> {
ctx.getExecution().get(PathBindingStorage.TYPE).push(pathBinding);
ctx.next();
},
handler);
}
try {
return new DefaultHandlingResult(
request, results, responseHeaders, registry, timeout, handler);
} catch (Exception e) {
throw Exceptions.uncheck(e);
} finally {
registry.get(ExecController.class).close();
}
}
/**
* Get HttpResourceModel which matches the HttpMethod of the request.
*
* @param routableDestinations List of ResourceModels.
* @param targetHttpMethod HttpMethod.
* @param requestUri request URI.
* @return RoutableDestination that matches httpMethod that needs to be handled. null if there are
* no matches.
*/
private List<PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel>>
getMatchedDestination(
List<PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel>>
routableDestinations,
HttpMethod targetHttpMethod,
String requestUri) {
Iterable<String> requestUriParts = Splitter.on('/').omitEmptyStrings().split(requestUri);
List<PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel>> matchedDestinations =
Lists.newArrayListWithExpectedSize(routableDestinations.size());
int maxExactMatch = 0;
int maxGroupMatch = 0;
int maxPatternLength = 0;
for (PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel> destination :
routableDestinations) {
HttpResourceModel resourceModel = destination.getDestination();
int groupMatch = destination.getGroupNameValues().size();
for (HttpMethod httpMethod : resourceModel.getHttpMethod()) {
if (targetHttpMethod.equals(httpMethod)) {
int exactMatch =
getExactPrefixMatchCount(
requestUriParts,
Splitter.on('/').omitEmptyStrings().split(resourceModel.getPath()));
// When there are multiple matches present, the following precedence order is used -
// 1. template path that has highest exact prefix match with the url is chosen.
// 2. template path has the maximum groups is chosen.
// 3. finally, template path that has the longest length is chosen.
if (exactMatch > maxExactMatch) {
maxExactMatch = exactMatch;
maxGroupMatch = groupMatch;
maxPatternLength = resourceModel.getPath().length();
matchedDestinations.clear();
matchedDestinations.add(destination);
} else if (exactMatch == maxExactMatch && groupMatch >= maxGroupMatch) {
if (groupMatch > maxGroupMatch || resourceModel.getPath().length() > maxPatternLength) {
maxGroupMatch = groupMatch;
maxPatternLength = resourceModel.getPath().length();
matchedDestinations.clear();
}
matchedDestinations.add(destination);
}
}
}
}
return matchedDestinations;
}
@Override
protected void messageReceived(ChannelHandlerContext ctx, Object msg) {
if (msg instanceof HttpRequest) {
HttpRequest request = _request = (HttpRequest) msg;
HttpMethod method = request.method();
HttpHeaders headers = request.headers();
QueryStringDecoder query = new QueryStringDecoder(request.uri());
if (HttpHeaderUtil.is100ContinueExpected(request))
ctx.write(new DefaultFullHttpResponse(HTTP_1_1, CONTINUE));
// if (headers != null) for (Map.Entry<CharSequence, CharSequence> h : headers) {}
if (method.equals(HttpMethod.GET)) RamdRequest.build(query.path(), query.parameters());
}
if (msg instanceof HttpContent) {
ByteBuf bb = ((HttpContent) msg).content();
if (bb.isReadable()) {}
_buf.append("Done.");
writeResponse((HttpContent) msg, ctx);
}
}
// Build the HTTP request based on the given parameters
private HttpRequest buildRequest(
String path, String method, List<HttpParam> parametersQuery, List<HttpParam> parametersForm) {
String queryString = String.format("?api_key=%s:%s", username, password);
for (HttpParam hp : parametersQuery) {
if (hp.value != null && !hp.value.isEmpty()) {
queryString += "&" + hp.name + "=" + hp.value;
}
}
DefaultHttpRequest request =
new DefaultHttpRequest(
HttpVersion.HTTP_1_1,
HttpMethod.valueOf(method),
baseUri.getPath() + "ari" + path + queryString);
// System.out.println(request.getUri());
request.headers().set(HttpHeaders.Names.HOST, "localhost");
request.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
return request;
}
@Override
public int compareTo(HttpMethod o) {
return name().compareTo(o.name());
}
@Override
public void setMethod(String method) {
req.setMethod(HttpMethod.valueOf(method));
}