/*
* Copyright (c) 2011-2013 The original author or authors
* ------------------------------------------------------
* 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.core.http.impl;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.handler.codec.DecoderResult;
import io.netty.handler.codec.TooLongFrameException;
import io.netty.handler.codec.http.*;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketHandshakeException;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketVersion;
import io.netty.handler.stream.ChunkedFile;
import io.netty.util.ReferenceCountUtil;
import io.vertx.codegen.annotations.Nullable;
import io.vertx.core.AsyncResult;
import io.vertx.core.Handler;
import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.*;
import io.vertx.core.http.impl.ws.WebSocketFrameInternal;
import io.vertx.core.impl.ContextImpl;
import io.vertx.core.impl.VertxInternal;
import io.vertx.core.logging.Logger;
import io.vertx.core.logging.LoggerFactory;
import io.vertx.core.net.NetSocket;
import io.vertx.core.net.impl.ConnectionBase;
import io.vertx.core.net.impl.NetSocketImpl;
import io.vertx.core.net.impl.VertxNetHandler;
import io.vertx.core.spi.metrics.HttpServerMetrics;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.ArrayDeque;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import static io.netty.handler.codec.http.HttpResponseStatus.CONTINUE;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
/**
*
* This class is optimised for performance when used on the same event loop. However it can be used safely from other threads.
*
* The internal state is protected using the synchronized keyword. If always used on the same event loop, then
* we benefit from biased locking which makes the overhead of synchronized near zero.
*
* @author <a href="http://tfox.org">Tim Fox</a>
*/
class ServerConnection extends ConnectionBase implements HttpConnection {
private static final Logger log = LoggerFactory.getLogger(ServerConnection.class);
private static final int CHANNEL_PAUSE_QUEUE_SIZE = 5;
private final Queue<Object> pending = new ArrayDeque<>(8);
private final String serverOrigin;
private final HttpServerImpl server;
private WebSocketServerHandshaker handshaker;
private final HttpServerMetrics metrics;
private boolean requestFailed;
private Object requestMetric;
private Handler<HttpServerRequest> requestHandler;
private Handler<ServerWebSocket> wsHandler;
private HttpServerRequestImpl currentRequest;
private HttpServerResponseImpl pendingResponse;
private ServerWebSocketImpl ws;
private ChannelFuture lastWriteFuture;
private boolean channelPaused;
private boolean paused;
private boolean sentCheck;
private long bytesRead;
private long bytesWritten;
ServerConnection(VertxInternal vertx, HttpServerImpl server, Channel channel, ContextImpl context, String serverOrigin,
WebSocketServerHandshaker handshaker, HttpServerMetrics metrics) {
super(vertx, channel, context);
this.serverOrigin = serverOrigin;
this.server = server;
this.handshaker = handshaker;
this.metrics = metrics;
}
@Override
public HttpServerMetrics metrics() {
return metrics;
}
public synchronized void pause() {
if (!paused) {
paused = true;
}
}
public synchronized void resume() {
if (paused) {
paused = false;
checkNextTick();
}
}
synchronized void handleMessage(Object msg) {
if (paused || (pendingResponse != null && msg instanceof HttpRequest) || !pending.isEmpty()) {
//We queue requests if paused or a request is in progress to prevent responses being written in the wrong order
pending.add(msg);
if (pending.size() == CHANNEL_PAUSE_QUEUE_SIZE) {
//We pause the channel too, to prevent the queue growing too large, but we don't do this
//until the queue reaches a certain size, to avoid pausing it too often
super.doPause();
channelPaused = true;
}
} else {
processMessage(msg);
}
}
synchronized void responseComplete() {
if (metrics.isEnabled()) {
reportBytesWritten(bytesWritten);
bytesWritten = 0;
if (requestFailed) {
metrics.requestReset(requestMetric);
requestFailed = false;
} else {
metrics.responseEnd(requestMetric, pendingResponse);
}
}
pendingResponse = null;
checkNextTick();
}
synchronized void requestHandler(Handler<HttpServerRequest> handler) {
this.requestHandler = handler;
}
synchronized void wsHandler(Handler<ServerWebSocket> handler) {
this.wsHandler = handler;
}
String getServerOrigin() {
return serverOrigin;
}
Vertx vertx() {
return vertx;
}
@Override
public ChannelFuture writeToChannel(Object obj) {
if (metrics.isEnabled()) {
long bytes = getBytes(obj);
if (bytes == -1) {
log.warn("Metrics could not be updated to include bytes written because of unknown object " + obj.getClass() + " being written.");
} else {
bytesWritten += bytes;
}
}
return lastWriteFuture = super.writeToChannel(obj);
}
ServerWebSocket upgrade(HttpServerRequest request, HttpRequest nettyReq) {
if (ws != null) {
return ws;
}
handshaker = server.createHandshaker(channel, nettyReq);
if (handshaker == null) {
throw new IllegalStateException("Can't upgrade this request");
}
ws = new ServerWebSocketImpl(vertx, request.uri(), request.path(),
request.query(), request.headers(), this, handshaker.version() != WebSocketVersion.V00,
null, server.options().getMaxWebsocketFrameSize(), server.options().getMaxWebsocketMessageSize());
ws.setMetric(metrics.upgrade(requestMetric, ws));
try {
handshaker.handshake(channel, nettyReq);
} catch (WebSocketHandshakeException e) {
handleException(e);
} catch (Exception e) {
log.error("Failed to generate shake response", e);
}
ChannelHandler handler = channel.pipeline().get(HttpChunkContentCompressor.class);
if (handler != null) {
// remove compressor as its not needed anymore once connection was upgraded to websockets
channel.pipeline().remove(handler);
}
server.connectionMap().put(channel, this);
return ws;
}
boolean isSSL() {
return server.getSslHelper().isSSL();
}
NetSocket createNetSocket() {
NetSocketImpl socket = new NetSocketImpl(vertx, channel, context, server.getSslHelper(), metrics);
socket.metric(metric());
Map<Channel, NetSocketImpl> connectionMap = new HashMap<>(1);
connectionMap.put(channel, socket);
// Flush out all pending data
endReadAndFlush();
// remove old http handlers and replace the old handler with one that handle plain sockets
ChannelPipeline pipeline = channel.pipeline();
ChannelHandler compressor = pipeline.get(HttpChunkContentCompressor.class);
if (compressor != null) {
pipeline.remove(compressor);
}
pipeline.remove("httpDecoder");
if (pipeline.get("chunkedWriter") != null) {
pipeline.remove("chunkedWriter");
}
channel.pipeline().replace("handler", "handler", new VertxNetHandler<NetSocketImpl>(channel, socket, connectionMap) {
@Override
public void exceptionCaught(ChannelHandlerContext chctx, Throwable t) throws Exception {
// remove from the real mapping
server.removeChannel(channel);
super.exceptionCaught(chctx, t);
}
@Override
public void channelInactive(ChannelHandlerContext chctx) throws Exception {
// remove from the real mapping
server.removeChannel(channel);
super.channelInactive(chctx);
}
@Override
public void channelRead(ChannelHandlerContext chctx, Object msg) throws Exception {
if (msg instanceof HttpContent) {
ReferenceCountUtil.release(msg);
return;
}
super.channelRead(chctx, msg);
}
@Override
protected void handleMsgReceived(NetSocketImpl conn, Object msg) {
ByteBuf buf = (ByteBuf) msg;
conn.handleDataReceived(Buffer.buffer(buf));
}
});
// check if the encoder can be removed yet or not.
if (lastWriteFuture == null) {
channel.pipeline().remove("httpEncoder");
} else {
lastWriteFuture.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
channel.pipeline().remove("httpEncoder");
}
});
}
return socket;
}
private void handleRequest(HttpServerRequestImpl req, HttpServerResponseImpl resp) {
this.currentRequest = req;
pendingResponse = resp;
if (metrics.isEnabled()) {
requestMetric = metrics.requestBegin(metric(), req);
}
if (requestHandler != null) {
requestHandler.handle(req);
}
}
private void handleChunk(Buffer chunk) {
if (metrics.isEnabled()) {
bytesRead += chunk.length();
}
currentRequest.handleData(chunk);
}
private void handleEnd() {
currentRequest.handleEnd();
reportBytesRead(bytesRead);
currentRequest = null;
bytesRead = 0;
}
@Override
public synchronized void handleInterestedOpsChanged() {
if (!isNotWritable()) {
if (pendingResponse != null) {
pendingResponse.handleDrained();
} else if (ws != null) {
ws.writable();
}
}
}
@Override
public void close() {
if (handshaker == null) {
super.close();
} else {
endReadAndFlush();
handshaker.close(channel, new CloseWebSocketFrame(1000, null));
}
}
synchronized void handleWebsocketConnect(ServerWebSocketImpl ws) {
if (wsHandler != null) {
wsHandler.handle(ws);
this.ws = ws;
}
}
void write100Continue() {
channel.writeAndFlush(new DefaultFullHttpResponse(HTTP_1_1, CONTINUE));
}
synchronized private void handleWsFrame(WebSocketFrameInternal frame) {
if (ws != null) {
ws.handleFrame(frame);
}
}
synchronized protected void handleClosed() {
if (ws != null) {
if (metrics.isEnabled()) {
metrics.disconnected(ws.getMetric());
}
ws.setMetric(null);
}
super.handleClosed();
if (ws != null) {
ws.handleClosed();
}
if (pendingResponse != null) {
if (metrics.isEnabled()) {
metrics.requestReset(requestMetric);
}
pendingResponse.handleClosed();
}
}
public ContextImpl getContext() {
return super.getContext();
}
@Override
protected synchronized void handleException(Throwable t) {
super.handleException(t);
if (metrics.isEnabled()) {
requestFailed = true;
}
if (currentRequest != null) {
currentRequest.handleException(t);
}
if (pendingResponse != null) {
pendingResponse.handleException(t);
}
if (ws != null) {
ws.handleException(t);
}
}
protected void addFuture(Handler<AsyncResult<Void>> completionHandler, ChannelFuture future) {
super.addFuture(completionHandler, future);
}
@Override
protected boolean supportsFileRegion() {
return super.supportsFileRegion() && channel.pipeline().get(HttpChunkContentCompressor.class) == null;
}
protected ChannelFuture sendFile(RandomAccessFile file, long offset, long length) throws IOException {
return super.sendFile(file, offset, length);
}
private void processMessage(Object msg) {
if (msg instanceof HttpObject) {
HttpObject obj = (HttpObject) msg;
DecoderResult result = obj.decoderResult();
if (result.isFailure()) {
Throwable cause = result.cause();
if (cause instanceof TooLongFrameException) {
String causeMsg = cause.getMessage();
HttpVersion version;
if (msg instanceof HttpRequest) {
version = ((HttpRequest) msg).protocolVersion();
} else if (currentRequest != null) {
version = currentRequest.version() == io.vertx.core.http.HttpVersion.HTTP_1_0 ? HttpVersion.HTTP_1_0 : HttpVersion.HTTP_1_1;
} else {
version = HttpVersion.HTTP_1_1;
}
HttpResponseStatus status = causeMsg.startsWith("An HTTP line is larger than") ? HttpResponseStatus.REQUEST_URI_TOO_LONG : HttpResponseStatus.BAD_REQUEST;
DefaultFullHttpResponse resp = new DefaultFullHttpResponse(version, status);
writeToChannel(resp);
}
// That will close the connection as it is considered as unusable
channel.pipeline().fireExceptionCaught(result.cause());
return;
}
if (msg instanceof HttpRequest) {
HttpRequest request = (HttpRequest) msg;
if (server.options().isHandle100ContinueAutomatically()) {
if (HttpHeaders.is100ContinueExpected(request)) {
write100Continue();
}
}
HttpServerResponseImpl resp = new HttpServerResponseImpl(vertx, this, request);
HttpServerRequestImpl req = new HttpServerRequestImpl(this, request, resp);
handleRequest(req, resp);
}
if (msg instanceof HttpContent) {
HttpContent chunk = (HttpContent) msg;
if (chunk.content().isReadable()) {
Buffer buff = Buffer.buffer(chunk.content());
handleChunk(buff);
}
//TODO chunk trailers
if (msg instanceof LastHttpContent) {
if (!paused) {
handleEnd();
} else {
// Requeue
pending.add(LastHttpContent.EMPTY_LAST_CONTENT);
}
}
} } else if (msg instanceof WebSocketFrameInternal) {
WebSocketFrameInternal frame = (WebSocketFrameInternal) msg;
handleWsFrame(frame);
}
checkNextTick();
}
private void checkNextTick() {
// Check if there are more pending messages in the queue that can be processed next time around
if (!pending.isEmpty() && !sentCheck && !paused && (pendingResponse == null || pending.peek() instanceof HttpContent)) {
sentCheck = true;
vertx.runOnContext(v -> {
sentCheck = false;
if (!paused) {
Object msg = pending.poll();
if (msg != null) {
processMessage(msg);
}
if (channelPaused && pending.isEmpty()) {
//Resume the actual channel
ServerConnection.super.doResume();
channelPaused = false;
}
}
});
}
}
private long getBytes(Object obj) {
if (obj == null) return 0;
if (obj instanceof Buffer) {
return ((Buffer) obj).length();
} else if (obj instanceof ByteBuf) {
return ((ByteBuf) obj).readableBytes();
} else if (obj instanceof HttpContent) {
return ((HttpContent) obj).content().readableBytes();
} else if (obj instanceof WebSocketFrame) {
return ((WebSocketFrame) obj).binaryData().length();
} else if (obj instanceof FileRegion) {
return ((FileRegion) obj).count();
} else if (obj instanceof ChunkedFile) {
ChunkedFile file = (ChunkedFile) obj;
return file.endOffset() - file.startOffset();
} else {
return -1;
}
}
//
@Override
public synchronized ServerConnection closeHandler(Handler<Void> handler) {
return (ServerConnection) super.closeHandler(handler);
}
@Override
public synchronized ServerConnection exceptionHandler(Handler<Throwable> handler) {
return (ServerConnection) super.exceptionHandler(handler);
}
@Override
public HttpConnection goAway(long errorCode, int lastStreamId, Buffer debugData) {
throw new UnsupportedOperationException("HTTP/1.x connections don't support GOAWAY");
}
@Override
public HttpConnection goAwayHandler(@Nullable Handler<GoAway> handler) {
throw new UnsupportedOperationException("HTTP/1.x connections don't support GOAWAY");
}
@Override
public HttpConnection shutdownHandler(@Nullable Handler<Void> handler) {
throw new UnsupportedOperationException("HTTP/1.x connections don't support GOAWAY");
}
@Override
public HttpConnection shutdown() {
throw new UnsupportedOperationException("HTTP/1.x connections don't support GOAWAY");
}
@Override
public HttpConnection shutdown(long timeoutMs) {
throw new UnsupportedOperationException("HTTP/1.x connections don't support GOAWAY");
}
@Override
public Http2Settings settings() {
throw new UnsupportedOperationException("HTTP/1.x connections don't support SETTINGS");
}
@Override
public HttpConnection updateSettings(Http2Settings settings) {
throw new UnsupportedOperationException("HTTP/1.x connections don't support SETTINGS");
}
@Override
public HttpConnection updateSettings(Http2Settings settings, Handler<AsyncResult<Void>> completionHandler) {
throw new UnsupportedOperationException("HTTP/1.x connections don't support SETTINGS");
}
@Override
public Http2Settings remoteSettings() {
throw new UnsupportedOperationException("HTTP/1.x connections don't support SETTINGS");
}
@Override
public HttpConnection remoteSettingsHandler(Handler<Http2Settings> handler) {
throw new UnsupportedOperationException("HTTP/1.x connections don't support SETTINGS");
}
@Override
public HttpConnection ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler) {
throw new UnsupportedOperationException("HTTP/1.x connections don't support PING");
}
@Override
public HttpConnection pingHandler(@Nullable Handler<Buffer> handler) {
throw new UnsupportedOperationException("HTTP/1.x connections don't support PING");
}
}