Java tutorial
/* * 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.buffer.Unpooled; import io.netty.channel.ChannelFuture; import io.netty.handler.codec.http.*; import io.netty.handler.codec.http.HttpVersion; import io.vertx.codegen.annotations.Nullable; import io.vertx.core.AsyncResult; import io.vertx.core.Future; import io.vertx.core.Handler; import io.vertx.core.MultiMap; import io.vertx.core.buffer.Buffer; import io.vertx.core.http.*; import io.vertx.core.http.HttpHeaders; import io.vertx.core.http.HttpMethod; 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 java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; /** * * This class is optimised for performance when used on the same event loop that is was passed to the handler with. * 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. * * It's important we don't have different locks for connection and request/response to avoid deadlock conditions * * @author <a href="http://tfox.org">Tim Fox</a> */ public class HttpServerResponseImpl implements HttpServerResponse { private static final Logger log = LoggerFactory.getLogger(HttpServerResponseImpl.class); private final VertxInternal vertx; private final ServerConnection conn; private final HttpResponse response; private final HttpVersion version; private final boolean keepAlive; private boolean headWritten; private boolean written; private Handler<Void> drainHandler; private Handler<Throwable> exceptionHandler; private Handler<Void> closeHandler; private Handler<Void> endHandler; private Handler<Void> headersEndHandler; private Handler<Void> bodyEndHandler; private boolean chunked; private boolean closed; private ChannelFuture channelFuture; private MultiMap headers; private LastHttpContent trailing; private MultiMap trailers; private String statusMessage; private long bytesWritten; HttpServerResponseImpl(final VertxInternal vertx, ServerConnection conn, HttpRequest request) { this.vertx = vertx; this.conn = conn; this.version = request.getProtocolVersion(); this.response = new DefaultHttpResponse(version, HttpResponseStatus.OK, false); this.keepAlive = (version == HttpVersion.HTTP_1_1 && !request.headers().contains(io.vertx.core.http.HttpHeaders.CONNECTION, HttpHeaders.CLOSE, true)) || (version == HttpVersion.HTTP_1_0 && request.headers() .contains(io.vertx.core.http.HttpHeaders.CONNECTION, HttpHeaders.KEEP_ALIVE, true)); } @Override public MultiMap headers() { if (headers == null) { headers = new HeadersAdaptor(response.headers()); } return headers; } @Override public MultiMap trailers() { if (trailers == null) { if (trailing == null) { trailing = new DefaultLastHttpContent(Unpooled.EMPTY_BUFFER, false); } trailers = new HeadersAdaptor(trailing.trailingHeaders()); } return trailers; } @Override public int getStatusCode() { return response.getStatus().code(); } @Override public HttpServerResponse setStatusCode(int statusCode) { HttpResponseStatus status = statusMessage != null ? new HttpResponseStatus(statusCode, statusMessage) : HttpResponseStatus.valueOf(statusCode); this.response.setStatus(status); return this; } @Override public String getStatusMessage() { return response.getStatus().reasonPhrase(); } @Override public HttpServerResponse setStatusMessage(String statusMessage) { synchronized (conn) { this.statusMessage = statusMessage; this.response.setStatus(new HttpResponseStatus(response.getStatus().code(), statusMessage)); return this; } } @Override public HttpServerResponseImpl setChunked(boolean chunked) { synchronized (conn) { checkWritten(); // HTTP 1.0 does not support chunking so we ignore this if HTTP 1.0 if (version != HttpVersion.HTTP_1_0) { this.chunked = chunked; } return this; } } @Override public boolean isChunked() { synchronized (conn) { return chunked; } } @Override public HttpServerResponseImpl putHeader(String key, String value) { synchronized (conn) { checkWritten(); headers().set(key, value); return this; } } @Override public HttpServerResponseImpl putHeader(String key, Iterable<String> values) { synchronized (conn) { checkWritten(); headers().set(key, values); return this; } } @Override public HttpServerResponseImpl putTrailer(String key, String value) { synchronized (conn) { checkWritten(); trailers().set(key, value); return this; } } @Override public HttpServerResponseImpl putTrailer(String key, Iterable<String> values) { synchronized (conn) { checkWritten(); trailers().set(key, values); return this; } } @Override public HttpServerResponse putHeader(CharSequence name, CharSequence value) { synchronized (conn) { checkWritten(); headers().set(name, value); return this; } } @Override public HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values) { synchronized (conn) { checkWritten(); headers().set(name, values); return this; } } @Override public HttpServerResponse putTrailer(CharSequence name, CharSequence value) { synchronized (conn) { checkWritten(); trailers().set(name, value); return this; } } @Override public HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value) { synchronized (conn) { checkWritten(); trailers().set(name, value); return this; } } @Override public HttpServerResponse setWriteQueueMaxSize(int size) { synchronized (conn) { checkWritten(); conn.doSetWriteQueueMaxSize(size); return this; } } @Override public boolean writeQueueFull() { synchronized (conn) { checkWritten(); return conn.isNotWritable(); } } @Override public HttpServerResponse drainHandler(Handler<Void> handler) { synchronized (conn) { checkWritten(); this.drainHandler = handler; conn.getContext().runOnContext(v -> conn.handleInterestedOpsChanged()); return this; } } @Override public HttpServerResponse exceptionHandler(Handler<Throwable> handler) { synchronized (conn) { checkWritten(); this.exceptionHandler = handler; return this; } } @Override public HttpServerResponse closeHandler(Handler<Void> handler) { synchronized (conn) { checkWritten(); this.closeHandler = handler; return this; } } @Override public HttpServerResponse endHandler(@Nullable Handler<Void> handler) { synchronized (conn) { checkWritten(); this.endHandler = handler; return this; } } @Override public HttpServerResponseImpl write(Buffer chunk) { ByteBuf buf = chunk.getByteBuf(); return write(buf); } @Override public HttpServerResponseImpl write(String chunk, String enc) { return write(Buffer.buffer(chunk, enc).getByteBuf()); } @Override public HttpServerResponseImpl write(String chunk) { return write(Buffer.buffer(chunk).getByteBuf()); } @Override public HttpServerResponse writeContinue() { conn.write100Continue(); return this; } @Override public void end(String chunk) { end(Buffer.buffer(chunk)); } @Override public void end(String chunk, String enc) { end(Buffer.buffer(chunk, enc)); } @Override public void end(Buffer chunk) { synchronized (conn) { if (!chunked && !contentLengthSet()) { headers().set(HttpHeaders.CONTENT_LENGTH, String.valueOf(chunk.length())); } ByteBuf buf = chunk.getByteBuf(); end0(buf); } } @Override public void close() { synchronized (conn) { if (!closed) { if (headWritten) { closeConnAfterWrite(); } else { conn.close(); } closed = true; } } } @Override public void end() { synchronized (conn) { end0(Unpooled.EMPTY_BUFFER); } } @Override public HttpServerResponseImpl sendFile(String filename, long offset, long length) { doSendFile(filename, offset, length, null); return this; } @Override public HttpServerResponse sendFile(String filename, long start, long end, Handler<AsyncResult<Void>> resultHandler) { doSendFile(filename, start, end, resultHandler); return this; } @Override public boolean ended() { synchronized (conn) { return written; } } @Override public boolean closed() { synchronized (conn) { return closed; } } @Override public boolean headWritten() { synchronized (conn) { return headWritten; } } @Override public long bytesWritten() { synchronized (conn) { return bytesWritten; } } @Override public HttpServerResponse headersEndHandler(Handler<Void> handler) { synchronized (conn) { this.headersEndHandler = handler; return this; } } @Override public HttpServerResponse bodyEndHandler(Handler<Void> handler) { synchronized (conn) { this.bodyEndHandler = handler; return this; } } private void end0(ByteBuf data) { checkWritten(); bytesWritten += data.readableBytes(); if (!headWritten) { // if the head was not written yet we can write out everything in one go // which is cheaper. prepareHeaders(); FullHttpResponse resp; if (trailing != null) { resp = new AssembledFullHttpResponse(response, data, trailing.trailingHeaders(), trailing.getDecoderResult()); } else { resp = new AssembledFullHttpResponse(response, data); } channelFuture = conn.writeToChannel(resp); } else { if (!data.isReadable()) { if (trailing == null) { channelFuture = conn.writeToChannel(LastHttpContent.EMPTY_LAST_CONTENT); } else { channelFuture = conn.writeToChannel(trailing); } } else { LastHttpContent content; if (trailing != null) { content = new AssembledLastHttpContent(data, trailing.trailingHeaders(), trailing.getDecoderResult()); } else { content = new DefaultLastHttpContent(data, false); } channelFuture = conn.writeToChannel(content); } } if (!keepAlive) { closeConnAfterWrite(); closed = true; } written = true; conn.responseComplete(); if (bodyEndHandler != null) { bodyEndHandler.handle(null); } if (endHandler != null) { endHandler.handle(null); } } private void doSendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler) { synchronized (conn) { if (headWritten) { throw new IllegalStateException("Head already written"); } checkWritten(); File file = vertx.resolveFile(filename); if (!file.exists()) { if (resultHandler != null) { ContextImpl ctx = vertx.getOrCreateContext(); ctx.runOnContext((v) -> resultHandler.handle(Future.failedFuture(new FileNotFoundException()))); } else { log.error("File not found: " + filename); } return; } long contentLength = Math.min(length, file.length() - offset); bytesWritten = contentLength; if (!contentLengthSet()) { putHeader(HttpHeaders.CONTENT_LENGTH, String.valueOf(contentLength)); } if (!contentTypeSet()) { String contentType = MimeMapping.getMimeTypeForFilename(filename); if (contentType != null) { putHeader(HttpHeaders.CONTENT_TYPE, contentType); } } prepareHeaders(); RandomAccessFile raf = null; try { raf = new RandomAccessFile(file, "r"); conn.queueForWrite(response); conn.sendFile(raf, Math.min(offset, file.length()), contentLength); } catch (IOException e) { try { if (raf != null) { raf.close(); } } catch (IOException ignore) { } if (resultHandler != null) { ContextImpl ctx = vertx.getOrCreateContext(); ctx.runOnContext((v) -> resultHandler.handle(Future.failedFuture(e))); } else { log.error("Failed to send file", e); } return; } // write an empty last content to let the http encoder know the response is complete channelFuture = conn.writeToChannel(LastHttpContent.EMPTY_LAST_CONTENT); written = true; if (resultHandler != null) { ContextImpl ctx = vertx.getOrCreateContext(); channelFuture.addListener(future -> { AsyncResult<Void> res; if (future.isSuccess()) { res = Future.succeededFuture(); } else { res = Future.failedFuture(future.cause()); } ctx.runOnContext((v) -> resultHandler.handle(res)); }); } if (!keepAlive) { closeConnAfterWrite(); } conn.responseComplete(); if (bodyEndHandler != null) { bodyEndHandler.handle(null); } } } private boolean contentLengthSet() { if (headers == null) { return false; } return response.headers().contains(HttpHeaders.CONTENT_LENGTH); } private boolean contentTypeSet() { if (headers == null) { return false; } return response.headers().contains(HttpHeaders.CONTENT_TYPE); } private void closeConnAfterWrite() { if (channelFuture != null) { channelFuture.addListener(fut -> conn.close()); } } void handleDrained() { synchronized (conn) { if (drainHandler != null) { drainHandler.handle(null); } } } void handleException(Throwable t) { synchronized (conn) { if (exceptionHandler != null) { exceptionHandler.handle(t); } } } void handleClosed() { synchronized (conn) { if (endHandler != null) { conn.getContext().runOnContext(endHandler); } if (closeHandler != null) { conn.getContext().runOnContext(closeHandler); } } } private void checkWritten() { if (written) { throw new IllegalStateException("Response has already been written"); } } private void prepareHeaders() { if (version == HttpVersion.HTTP_1_0 && keepAlive) { response.headers().set(HttpHeaders.CONNECTION, HttpHeaders.KEEP_ALIVE); } else if (version == HttpVersion.HTTP_1_1 && !keepAlive) { response.headers().set(HttpHeaders.CONNECTION, HttpHeaders.CLOSE); } if (chunked) { response.headers().set(HttpHeaders.TRANSFER_ENCODING, HttpHeaders.CHUNKED); } else if (keepAlive && !contentLengthSet()) { response.headers().set(HttpHeaders.CONTENT_LENGTH, "0"); } if (headersEndHandler != null) { headersEndHandler.handle(null); } headWritten = true; } private HttpServerResponseImpl write(ByteBuf chunk) { synchronized (conn) { checkWritten(); if (!headWritten && version != HttpVersion.HTTP_1_0 && !chunked && !contentLengthSet()) { throw new IllegalStateException( "You must set the Content-Length header to be the total size of the message " + "body BEFORE sending any data if you are not using HTTP chunked encoding."); } bytesWritten += chunk.readableBytes(); if (!headWritten) { prepareHeaders(); channelFuture = conn.writeToChannel(new AssembledHttpResponse(response, chunk)); } else { channelFuture = conn.writeToChannel(new DefaultHttpContent(chunk)); } return this; } } @Override public int streamId() { return -1; } @Override public void reset(long code) { } @Override public HttpServerResponse push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { return push(method, null, path, headers, handler); } @Override public HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler) { return push(method, path, handler); } @Override public HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler) { return push(method, path, null, null, handler); } @Override public HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { handler.handle(Future.failedFuture("Push promise is only supported with HTTP2")); return this; } @Override public HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload) { return this; } }