Java tutorial
/* * Copyright 2016 The Simple File Server Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.sfs; import com.google.common.base.Preconditions; import io.vertx.core.AsyncResult; import io.vertx.core.Handler; import io.vertx.core.MultiMap; import io.vertx.core.buffer.Buffer; import io.vertx.core.http.HttpConnection; import io.vertx.core.http.HttpFrame; import io.vertx.core.http.HttpMethod; import io.vertx.core.http.HttpServerFileUpload; import io.vertx.core.http.HttpServerRequest; import io.vertx.core.http.HttpServerResponse; import io.vertx.core.http.HttpVersion; import io.vertx.core.http.ServerWebSocket; import io.vertx.core.net.NetSocket; import io.vertx.core.net.SocketAddress; import org.sfs.auth.UserAndRole; import org.sfs.rx.ObservableFuture; import org.sfs.rx.RxHelper; import org.sfs.util.KeepAliveHttpServerResponse; import rx.Observable; import javax.net.ssl.SSLPeerUnverifiedException; import javax.security.cert.X509Certificate; import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; import static java.util.concurrent.TimeUnit.MILLISECONDS; import static org.sfs.util.SfsHttpHeaders.X_SFS_KEEP_ALIVE_TIMEOUT; public class SfsRequest implements HttpServerRequest { private final HttpServerRequest httpServerRequest; private final VertxContext<Server> vertxContext; private Map<String, Object> context; private boolean wroteData = false; private KeepAliveHttpServerResponse keepAliveHttpServerResponse; private ResponseWrapper responseWrapper; private UserAndRole userAndRole; public SfsRequest(VertxContext<Server> vertxContext, HttpServerRequest httpServerRequest) { this.vertxContext = vertxContext; this.httpServerRequest = httpServerRequest; this.responseWrapper = new ResponseWrapper(this); } public SfsRequest startProxyKeepAlive() { MultiMap headers = httpServerRequest.headers(); long keepAliveTimeout = Long.parseLong( headers.contains(X_SFS_KEEP_ALIVE_TIMEOUT) ? headers.get(X_SFS_KEEP_ALIVE_TIMEOUT) : "10000"); startProxyKeepAlive(keepAliveTimeout, MILLISECONDS); return this; } public SfsRequest startProxyKeepAlive(long timeout, TimeUnit timeUnit) { Preconditions.checkState(!wroteData, "HttpServerResponse has already been used"); if (keepAliveHttpServerResponse == null) { keepAliveHttpServerResponse = new KeepAliveHttpServerResponse(vertxContext(), timeout, timeUnit, httpServerRequest.response()); } return this; } public Observable<Void> stopKeepAlive() { if (keepAliveHttpServerResponse != null) { ObservableFuture<Void> handler = RxHelper.observableFuture(); keepAliveHttpServerResponse.stopKeepAlive(handler); return handler; } else { return Observable.just(null); } } public UserAndRole getUserAndRole() { return userAndRole; } public void setUserAndRole(UserAndRole userAndRole) { this.userAndRole = userAndRole; } public boolean proxyKeepAliveStarted() { return keepAliveHttpServerResponse != null; } public VertxContext<Server> vertxContext() { return vertxContext; } public Map<String, Object> context() { if (context == null) { context = new HashMap<>(); } return context; } @Override public HttpVersion version() { return httpServerRequest.version(); } @Override public HttpMethod method() { return httpServerRequest.method(); } @Override public String uri() { return httpServerRequest.uri(); } @Override public String path() { return httpServerRequest.path(); } @Override public String query() { return httpServerRequest.query(); } @Override public HttpServerResponse response() { if (keepAliveHttpServerResponse != null) { return keepAliveHttpServerResponse; } return responseWrapper; } @Override public MultiMap headers() { return httpServerRequest.headers(); } @Override public MultiMap params() { return httpServerRequest.params(); } @Override public SocketAddress remoteAddress() { return httpServerRequest.remoteAddress(); } @Override public SocketAddress localAddress() { return httpServerRequest.localAddress(); } @Override public X509Certificate[] peerCertificateChain() throws SSLPeerUnverifiedException { return httpServerRequest.peerCertificateChain(); } @Override public String absoluteURI() { return httpServerRequest.absoluteURI(); } @Override public SfsRequest bodyHandler(Handler<Buffer> bodyHandler) { httpServerRequest.bodyHandler(bodyHandler); return this; } @Override public NetSocket netSocket() { return httpServerRequest.netSocket(); } @Override public SfsRequest setExpectMultipart(boolean expect) { httpServerRequest.setExpectMultipart(expect); return this; } @Override public SfsRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler) { httpServerRequest.uploadHandler(uploadHandler); return this; } @Override public MultiMap formAttributes() { return httpServerRequest.formAttributes(); } @Override public SfsRequest endHandler(Handler<Void> endHandler) { httpServerRequest.endHandler(endHandler); return this; } @Override public SfsRequest handler(Handler<Buffer> handler) { httpServerRequest.handler(handler); return this; } @Override public SfsRequest pause() { httpServerRequest.pause(); return this; } @Override public SfsRequest resume() { httpServerRequest.resume(); return this; } @Override public SfsRequest exceptionHandler(Handler<Throwable> handler) { httpServerRequest.exceptionHandler(handler); return this; } @Override public String rawMethod() { return httpServerRequest.rawMethod(); } @Override public boolean isSSL() { return httpServerRequest.isSSL(); } @Override public String scheme() { return httpServerRequest.scheme(); } @Override public String host() { return httpServerRequest.host(); } @Override public String getHeader(String headerName) { return httpServerRequest.getHeader(headerName); } @Override public String getHeader(CharSequence headerName) { return httpServerRequest.getHeader(headerName); } @Override public String getParam(String paramName) { return httpServerRequest.getParam(paramName); } @Override public boolean isExpectMultipart() { return httpServerRequest.isExpectMultipart(); } @Override public String getFormAttribute(String attributeName) { return httpServerRequest.getFormAttribute(attributeName); } @Override public ServerWebSocket upgrade() { return httpServerRequest.upgrade(); } @Override public boolean isEnded() { return httpServerRequest.isEnded(); } @Override public HttpServerRequest customFrameHandler(Handler<HttpFrame> handler) { return httpServerRequest.customFrameHandler(handler); } @Override public HttpConnection connection() { return httpServerRequest.connection(); } private static class ResponseWrapper implements HttpServerResponse { private final SfsRequest httpServerRequest; private final HttpServerResponse response; public ResponseWrapper(SfsRequest request) { this.httpServerRequest = request; this.response = request.httpServerRequest.response(); } @Override public int getStatusCode() { return response.getStatusCode(); } @Override public HttpServerResponse setStatusCode(int statusCode) { return response.setStatusCode(statusCode); } @Override public String getStatusMessage() { return response.getStatusMessage(); } @Override public HttpServerResponse setStatusMessage(String statusMessage) { response.setStatusMessage(statusMessage); return this; } @Override public HttpServerResponse setChunked(boolean chunked) { response.setChunked(chunked); return this; } @Override public boolean isChunked() { return response.isChunked(); } @Override public MultiMap headers() { return response.headers(); } @Override public HttpServerResponse putHeader(String name, String value) { response.putHeader(name, value); return this; } @Override public HttpServerResponse putHeader(CharSequence name, CharSequence value) { response.putHeader(name, value); return this; } @Override public HttpServerResponse putHeader(String name, Iterable<String> values) { response.putHeader(name, values); return this; } @Override public HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values) { response.putHeader(name, values); return this; } @Override public MultiMap trailers() { return response.trailers(); } @Override public HttpServerResponse putTrailer(String name, String value) { response.putTrailer(name, value); return this; } @Override public HttpServerResponse putTrailer(CharSequence name, CharSequence value) { response.putTrailer(name, value); return this; } @Override public HttpServerResponse putTrailer(String name, Iterable<String> values) { response.putTrailer(name, values); return this; } @Override public HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value) { response.putTrailer(name, value); return this; } @Override public HttpServerResponse closeHandler(Handler<Void> handler) { response.closeHandler(handler); return this; } @Override public HttpServerResponse write(Buffer chunk) { httpServerRequest.wroteData = true; response.write(chunk); return this; } @Override public HttpServerResponse write(String chunk, String enc) { httpServerRequest.wroteData = true; response.write(chunk, enc); return this; } @Override public void end(String chunk) { httpServerRequest.wroteData = true; response.end(chunk); } @Override public HttpServerResponse write(String chunk) { httpServerRequest.wroteData = true; response.write(chunk); return this; } @Override public void end(String chunk, String enc) { httpServerRequest.wroteData = true; response.end(chunk, enc); } @Override public void end(Buffer chunk) { httpServerRequest.wroteData = true; response.end(chunk); } @Override public void end() { httpServerRequest.wroteData = true; response.end(); } @Override public HttpServerResponse sendFile(String filename) { httpServerRequest.wroteData = true; response.sendFile(filename); return this; } @Override public HttpServerResponse sendFile(String filename, long offset) { httpServerRequest.wroteData = true; response.sendFile(filename, offset); return this; } @Override public HttpServerResponse sendFile(String filename, long offset, long length) { httpServerRequest.wroteData = true; response.sendFile(filename, offset, length); return this; } @Override public HttpServerResponse sendFile(String filename, Handler<AsyncResult<Void>> resultHandler) { httpServerRequest.wroteData = true; response.sendFile(filename, resultHandler); return this; } @Override public HttpServerResponse sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler) { httpServerRequest.wroteData = true; response.sendFile(filename, offset, resultHandler); return this; } @Override public HttpServerResponse sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler) { httpServerRequest.wroteData = true; response.sendFile(filename, offset, length, resultHandler); return this; } @Override public void close() { response.close(); } @Override public HttpServerResponse exceptionHandler(Handler<Throwable> handler) { response.exceptionHandler(handler); return this; } @Override public HttpServerResponse setWriteQueueMaxSize(int maxSize) { return response.setWriteQueueMaxSize(maxSize); } @Override public boolean writeQueueFull() { return response.writeQueueFull(); } @Override public HttpServerResponse drainHandler(Handler<Void> handler) { response.drainHandler(handler); return this; } @Override public HttpServerResponse writeContinue() { httpServerRequest.wroteData = true; response.writeContinue(); return this; } @Override public boolean ended() { return response.ended(); } @Override public boolean closed() { return response.closed(); } @Override public boolean headWritten() { return response.headWritten(); } @Override public HttpServerResponse headersEndHandler(Handler<Void> handler) { response.headersEndHandler(handler); return this; } @Override public HttpServerResponse bodyEndHandler(Handler<Void> handler) { response.bodyEndHandler(handler); return this; } @Override public long bytesWritten() { return response.bytesWritten(); } @Override public int streamId() { return response.streamId(); } @Override public HttpServerResponse push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler) { httpServerRequest.wroteData = true; response.push(method, host, path, handler); return this; } @Override public HttpServerResponse push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { httpServerRequest.wroteData = true; response.push(method, path, headers, handler); return this; } @Override public HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler) { httpServerRequest.wroteData = true; response.push(method, path, handler); return this; } @Override public HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { httpServerRequest.wroteData = true; response.push(method, host, path, headers, handler); return this; } @Override public void reset(long code) { response.reset(code); } @Override public HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload) { httpServerRequest.wroteData = true; response.writeCustomFrame(type, flags, payload); return this; } } }