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.
com.arangodb.shaded.vertx.core.http.impl.HttpNetSocket Maven / Gradle / Ivy
/*
* Copyright (c) 2011-2019 Contributors to the Eclipse Foundation
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
* which is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
*/
package com.arangodb.shaded.vertx.core.http.impl;
import com.arangodb.shaded.vertx.codegen.annotations.Nullable;
import com.arangodb.shaded.vertx.core.*;
import com.arangodb.shaded.vertx.core.buffer.Buffer;
import com.arangodb.shaded.vertx.core.file.AsyncFile;
import com.arangodb.shaded.vertx.core.http.HttpClosedException;
import com.arangodb.shaded.vertx.core.http.StreamResetException;
import com.arangodb.shaded.vertx.core.impl.ContextInternal;
import com.arangodb.shaded.vertx.core.impl.VertxInternal;
import com.arangodb.shaded.vertx.core.net.NetSocket;
import com.arangodb.shaded.vertx.core.net.SocketAddress;
import com.arangodb.shaded.vertx.core.net.impl.ConnectionBase;
import com.arangodb.shaded.vertx.core.streams.ReadStream;
import com.arangodb.shaded.vertx.core.streams.WriteStream;
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLSession;
import javax.security.cert.X509Certificate;
import java.nio.channels.ClosedChannelException;
import java.security.cert.Certificate;
import java.util.List;
/**
* @author Julien Viet
*/
class HttpNetSocket implements NetSocket {
static HttpNetSocket netSocket(ConnectionBase conn, ContextInternal context, ReadStream readStream, WriteStream writeStream) {
HttpNetSocket sock = new HttpNetSocket(conn, context, readStream, writeStream);
readStream.handler(sock::handleData);
readStream.endHandler(sock::handleEnd);
readStream.exceptionHandler(sock::handleException);
return sock;
}
private final ConnectionBase conn;
private final ContextInternal context;
private final ReadStream readStream;
private final WriteStream writeStream;
private Handler exceptionHandler;
private Handler closeHandler;
private Handler endHandler;
private Handler dataHandler;
private HttpNetSocket(ConnectionBase conn, ContextInternal context, ReadStream readStream, WriteStream writeStream) {
this.conn = conn;
this.context = context;
this.readStream = readStream;
this.writeStream = writeStream;
}
private void handleEnd(Void v) {
Handler endHandler = endHandler();
if (endHandler != null) {
// Give opportunity to send a last chunk
endHandler.handle(null);
}
Handler closeHandler = closeHandler();
if (closeHandler != null) {
closeHandler.handle(null);
}
}
private void handleData(Buffer buf) {
Handler handler = handler();
if (handler != null) {
handler.handle(buf);
}
}
private void handleException(Throwable cause) {
Handler handler = exceptionHandler();
if (handler != null) {
handler.handle(cause);
}
if (cause instanceof HttpClosedException) {
Handler endHandler = endHandler();
if (endHandler != null) {
endHandler.handle(null);
}
}
if (cause instanceof StreamResetException || cause instanceof HttpClosedException) {
Handler closeHandler = closeHandler();
if (closeHandler != null) {
closeHandler.handle(null);
}
}
}
@Override
public synchronized NetSocket exceptionHandler(Handler handler) {
exceptionHandler = handler;
return this;
}
synchronized Handler exceptionHandler() {
return exceptionHandler;
}
@Override
public synchronized NetSocket handler(Handler handler) {
dataHandler = handler;
return this;
}
synchronized Handler handler() {
return dataHandler;
}
@Override
public NetSocket fetch(long amount) {
readStream.fetch(amount);
return this;
}
@Override
public NetSocket pause() {
readStream.pause();
return this;
}
@Override
public NetSocket resume() {
readStream.resume();
return this;
}
@Override
public synchronized NetSocket endHandler(Handler handler) {
endHandler = handler;
return this;
}
synchronized Handler endHandler() {
return endHandler;
}
@Override
public NetSocket setWriteQueueMaxSize(int maxSize) {
writeStream.setWriteQueueMaxSize(maxSize);
return this;
}
@Override
public NetSocket drainHandler(Handler handler) {
writeStream.drainHandler(handler);
return this;
}
@Override
public boolean writeQueueFull() {
return writeStream.writeQueueFull();
}
@Override
public String writeHandlerID() {
return null;
}
@Override
public Future write(Buffer data) {
return writeStream.write(data);
}
@Override
public void write(Buffer data, Handler> handler) {
writeStream.write(data, handler);
}
@Override
public Future write(String str, String enc) {
return write(Buffer.buffer(str, enc));
}
@Override
public void write(String str, String enc, Handler> handler) {
writeStream.write(Buffer.buffer(str, enc), handler);
}
@Override
public Future write(String str) {
return writeStream.write(Buffer.buffer(str));
}
@Override
public void write(String str, Handler> handler) {
writeStream.write(Buffer.buffer(str), handler);
}
@Override
public Future end(Buffer data) {
return writeStream.end(data);
}
@Override
public void end(Buffer buffer, Handler> handler) {
writeStream.end(buffer, handler);
}
@Override
public Future end() {
return writeStream.end();
}
@Override
public void end(Handler> handler) {
writeStream.end(handler);
}
@Override
public Future sendFile(String filename, long offset, long length) {
Promise promise = context.promise();
sendFile(filename, offset, length, promise);
return promise.future();
}
@Override
public NetSocket sendFile(String filename, long offset, long length, Handler> resultHandler) {
VertxInternal vertx = conn.getContext().owner();
Handler> h;
if (resultHandler != null) {
Context resultCtx = vertx.getOrCreateContext();
h = ar -> {
resultCtx.runOnContext((v) -> {
resultHandler.handle(ar);
});
};
} else {
h = ar -> {};
}
HttpUtils.resolveFile(vertx, filename, offset, length, ar -> {
if (ar.succeeded()) {
AsyncFile file = ar.result();
file.pipe()
.endOnComplete(false)
.to(this, ar1 -> file.close(ar2 -> {
Throwable failure = ar1.failed() ? ar1.cause() : ar2.failed() ? ar2.cause() : null;
if(failure == null)
h.handle(ar1);
else
h.handle(Future.failedFuture(failure));
}));
} else {
h.handle(ar.mapEmpty());
}
});
return this;
}
@Override
public SocketAddress remoteAddress() {
return conn.remoteAddress();
}
@Override
public SocketAddress remoteAddress(boolean real) {
return conn.remoteAddress(real);
}
@Override
public SocketAddress localAddress() {
return conn.localAddress();
}
@Override
public SocketAddress localAddress(boolean real) {
return conn.localAddress(real);
}
@Override
public Future close() {
return end();
}
@Override
public void close(Handler> handler) {
end(handler);
}
@Override
public NetSocket closeHandler(@Nullable Handler handler) {
synchronized (conn) {
closeHandler = handler;
}
return this;
}
Handler closeHandler() {
synchronized (conn) {
return closeHandler;
}
}
@Override
public NetSocket upgradeToSsl(Handler> handler) {
handler.handle(upgradeToSsl());
return this;
}
@Override
public NetSocket upgradeToSsl(String serverName, Handler> handler) {
handler.handle(upgradeToSsl(serverName));
return this;
}
@Override
public Future upgradeToSsl() {
return Future.failedFuture("Cannot upgrade stream to SSL");
}
@Override
public Future upgradeToSsl(String serverName) {
return Future.failedFuture("Cannot upgrade stream to SSL");
}
@Override
public boolean isSsl() {
return conn.isSsl();
}
@Override
public SSLSession sslSession() {
return conn.sslSession();
}
@Override
public X509Certificate[] peerCertificateChain() throws SSLPeerUnverifiedException {
return conn.peerCertificateChain();
}
@Override
public List peerCertificates() throws SSLPeerUnverifiedException {
return conn.peerCertificates();
}
@Override
public String indicatedServerName() {
return conn.indicatedServerName();
}
@Override
public String applicationLayerProtocol() {
return null;
}
}
