diff --git a/src/main/asciidoc/http.adoc b/src/main/asciidoc/http.adoc
index 3d237dcf06d..ebaebac5f57 100644
--- a/src/main/asciidoc/http.adoc
+++ b/src/main/asciidoc/http.adoc
@@ -1550,7 +1550,7 @@ method.
The {@link io.vertx.core.http.HttpClientOptions#setSsl(boolean)} setting acts as the default client setting.
-The {@link io.vertx.core.http.RequestOptions#setSsl(boolean)} overrides the default client setting
+The {@link io.vertx.core.http.RequestOptions#setSsl(Boolean)} overrides the default client setting
* setting the value to `false` will disable SSL/TLS even if the client is configured to use SSL/TLS
* setting the value to `true` will enable SSL/TLS even if the client is configured to not use SSL/TLS, the actual
diff --git a/src/main/asciidoc/index.adoc b/src/main/asciidoc/index.adoc
index d47267196a3..c13155f2794 100644
--- a/src/main/asciidoc/index.adoc
+++ b/src/main/asciidoc/index.adoc
@@ -1449,28 +1449,33 @@ Native on BSD gives you extra networking options:
=== Domain sockets
-Natives provide domain sockets support for `NetServer` and `HttpServer`:
+Natives provide domain sockets support for servers:
[source,$lang]
----
-{@link examples.CoreExamples#serverWithDomainSockets}
+{@link examples.CoreExamples#tcpServerWithDomainSockets}
----
-Or for http:
+or for http:
+
[source,$lang]
----
{@link examples.CoreExamples#httpServerWithDomainSockets}
----
-
-As well as `NetClient`:
+As well as clients:
[source,$lang]
----
-{@link examples.CoreExamples#clientWithDomainSockets}
+{@link examples.CoreExamples#tcpClientWithDomainSockets}
----
-NOTE: support for `HttpClient` can be expected in later versions of Vert.x
+or for http:
+
+[source,$lang]
+----
+{@link examples.CoreExamples#httpClientWithDomainSockets}
+----
== Security notes
diff --git a/src/main/java/examples/CoreExamples.java b/src/main/java/examples/CoreExamples.java
index 2f1db8eec7d..3a745d314ee 100644
--- a/src/main/java/examples/CoreExamples.java
+++ b/src/main/java/examples/CoreExamples.java
@@ -15,6 +15,8 @@
import io.vertx.core.buffer.Buffer;
import io.vertx.core.dns.AddressResolverOptions;
import io.vertx.core.file.FileSystem;
+import io.vertx.core.http.HttpClient;
+import io.vertx.core.http.HttpMethod;
import io.vertx.core.http.HttpServer;
import io.vertx.core.http.HttpServerOptions;
import io.vertx.core.http.HttpServerRequest;
@@ -392,7 +394,7 @@ public void configureBSDOptions(Vertx vertx, boolean reusePort) {
vertx.createHttpServer(new HttpServerOptions().setReusePort(reusePort));
}
- public void serverWithDomainSockets(Vertx vertx) {
+ public void tcpServerWithDomainSockets(Vertx vertx) {
// Only available on BSD and Linux
vertx.createNetServer().connectHandler(so -> {
// Handle application
@@ -411,11 +413,14 @@ public void httpServerWithDomainSockets(Vertx vertx) {
});
}
- public void clientWithDomainSockets(Vertx vertx) {
+ public void tcpClientWithDomainSockets(Vertx vertx) {
NetClient netClient = vertx.createNetClient();
// Only available on BSD and Linux
- netClient.connect(SocketAddress.domainSocketAddress("/var/tmp/myservice.sock"), ar -> {
+ SocketAddress addr = SocketAddress.domainSocketAddress("/var/tmp/myservice.sock");
+
+ // Connect to the server
+ netClient.connect(addr, ar -> {
if (ar.succeeded()) {
// Connected
} else {
@@ -423,4 +428,16 @@ public void clientWithDomainSockets(Vertx vertx) {
}
});
}
+
+ public void httpClientWithDomainSockets(Vertx vertx) {
+ HttpClient httpClient = vertx.createHttpClient();
+
+ // Only available on BSD and Linux
+ SocketAddress addr = SocketAddress.domainSocketAddress("/var/tmp/myservice.sock");
+
+ // Send request to the server
+ httpClient.request(HttpMethod.GET, addr, 8080, "localhost", "/", resp -> {
+ // Process response
+ }).end();
+ }
}
diff --git a/src/main/java/io/vertx/core/http/HttpClient.java b/src/main/java/io/vertx/core/http/HttpClient.java
index 69b01743b57..2dda2a39825 100644
--- a/src/main/java/io/vertx/core/http/HttpClient.java
+++ b/src/main/java/io/vertx/core/http/HttpClient.java
@@ -19,6 +19,7 @@
import io.vertx.core.Handler;
import io.vertx.core.MultiMap;
import io.vertx.core.metrics.Measured;
+import io.vertx.core.net.SocketAddress;
import io.vertx.core.streams.ReadStream;
import java.util.function.Function;
@@ -54,6 +55,16 @@
@VertxGen
public interface HttpClient extends Measured {
+ /**
+ * Like {@link #request(HttpMethod, RequestOptions)} using the {@code serverAddress} parameter to connect to the
+ * server instead of the {@code absoluteURI} parameter.
+ *
+ * The request host header will still be created from the {@code options} parameter.
+ *
+ * Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
+ */
+ HttpClientRequest request(HttpMethod method, SocketAddress serverAddress, RequestOptions options);
+
/**
* Create an HTTP request to send to the server with the specified options.
*
@@ -73,6 +84,16 @@ public interface HttpClient extends Measured {
*/
HttpClientRequest request(HttpMethod method, int port, String host, String requestURI);
+ /**
+ * Like {@link #request(HttpMethod, int, String, String)} using the {@code serverAddress} parameter to connect to the
+ * server instead of the {@code absoluteURI} parameter.
+ *
+ * The request host header will still be created from the {@code host} and {@code port} parameters.
+ *
+ * Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
+ */
+ HttpClientRequest request(HttpMethod method, SocketAddress serverAddress, int port, String host, String requestURI);
+
/**
* Create an HTTP request to send to the server at the specified host and default port.
* @param method the HTTP method
@@ -91,6 +112,16 @@ public interface HttpClient extends Measured {
*/
HttpClientRequest request(HttpMethod method, RequestOptions options, Handler> responseHandler);
+ /**
+ * Like {@link #request(HttpMethod, RequestOptions, Handler)} using the {@code serverAddress} parameter to connect to the
+ * server instead of the {@code absoluteURI} parameter.
+ *
+ * The request host header will still be created from the {@code options} parameter.
+ *
+ * Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
+ */
+ HttpClientRequest request(HttpMethod method, SocketAddress serverAddress, RequestOptions options, Handler> responseHandler);
+
/**
* Create an HTTP request to send to the server at the specified host and port, specifying a response handler to receive
* the response
@@ -103,6 +134,16 @@ public interface HttpClient extends Measured {
*/
HttpClientRequest request(HttpMethod method, int port, String host, String requestURI, Handler> responseHandler);
+ /**
+ * Like {@link #request(HttpMethod, int, String, String, Handler)} using the {@code serverAddress} parameter to connect to the
+ * server instead of the {@code absoluteURI} parameter.
+ *
+ * The request host header will still be created from the {@code host} and {@code port} parameters.
+ *
+ * Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
+ */
+ HttpClientRequest request(HttpMethod method, SocketAddress serverAddress, int port, String host, String requestURI, Handler> responseHandler);
+
/**
* Create an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive
* the response
@@ -140,6 +181,16 @@ public interface HttpClient extends Measured {
*/
HttpClientRequest requestAbs(HttpMethod method, String absoluteURI);
+ /**
+ * Like {@link #requestAbs(HttpMethod, String)} using the {@code serverAddress} parameter to connect to the
+ * server instead of the {@code absoluteURI} parameter.
+ *
+ * The request host header will still be created from the {@code absoluteURI} parameter.
+ *
+ * Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
+ */
+ HttpClientRequest requestAbs(HttpMethod method, SocketAddress serverAddress, String absoluteURI);
+
/**
* Create an HTTP request to send to the server using an absolute URI, specifying a response handler to receive
* the response
@@ -150,6 +201,16 @@ public interface HttpClient extends Measured {
*/
HttpClientRequest requestAbs(HttpMethod method, String absoluteURI, Handler> responseHandler);
+ /**
+ * Like {@link #requestAbs(HttpMethod, String, Handler)} using the {@code serverAddress} parameter to connect to the
+ * server instead of the {@code absoluteURI} parameter.
+ *
+ * The request host header will still be created from the {@code absoluteURI} parameter.
+ *
+ * Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
+ */
+ HttpClientRequest requestAbs(HttpMethod method, SocketAddress serverAddress, String absoluteURI, Handler> responseHandler);
+
/**
* Create an HTTP GET request to send to the server with the specified options.
* @param options the request options
diff --git a/src/main/java/io/vertx/core/http/RequestOptions.java b/src/main/java/io/vertx/core/http/RequestOptions.java
index 43cc94195d9..380e8bfb7a6 100644
--- a/src/main/java/io/vertx/core/http/RequestOptions.java
+++ b/src/main/java/io/vertx/core/http/RequestOptions.java
@@ -35,7 +35,7 @@ public class RequestOptions {
/**
* SSL enabled by default = false
*/
- public static final boolean DEFAULT_SSL = false;
+ public static final Boolean DEFAULT_SSL = null;
/**
* The default relative request URI = ""
@@ -44,7 +44,7 @@ public class RequestOptions {
private String host;
private int port;
- private boolean ssl;
+ private Boolean ssl;
private String uri;
/**
@@ -123,7 +123,7 @@ public RequestOptions setPort(int port) {
/**
* @return is SSL/TLS enabled?
*/
- public boolean isSsl() {
+ public Boolean isSsl() {
return ssl;
}
@@ -133,7 +133,7 @@ public boolean isSsl() {
* @param ssl true if enabled
* @return a reference to this, so the API can be used fluently
*/
- public RequestOptions setSsl(boolean ssl) {
+ public RequestOptions setSsl(Boolean ssl) {
this.ssl = ssl;
return this;
}
diff --git a/src/main/java/io/vertx/core/http/impl/ConnectionManager.java b/src/main/java/io/vertx/core/http/impl/ConnectionManager.java
index a4d45912505..fccf3d843f3 100644
--- a/src/main/java/io/vertx/core/http/impl/ConnectionManager.java
+++ b/src/main/java/io/vertx/core/http/impl/ConnectionManager.java
@@ -18,6 +18,7 @@
import io.vertx.core.http.HttpVersion;
import io.vertx.core.http.impl.pool.Pool;
import io.vertx.core.impl.ContextInternal;
+import io.vertx.core.net.SocketAddress;
import io.vertx.core.spi.metrics.HttpClientMetrics;
import java.util.*;
@@ -66,21 +67,19 @@ private synchronized void checkExpired(long period) {
private static final class EndpointKey {
private final boolean ssl;
- private final int port;
- private final String peerHost;
- private final String host;
+ private final SocketAddress server;
+ private final SocketAddress peerAddress;
- EndpointKey(boolean ssl, int port, String peerHost, String host) {
- if (host == null) {
+ EndpointKey(boolean ssl, SocketAddress server, SocketAddress peerAddress) {
+ if (server == null) {
throw new NullPointerException("No null host");
}
- if (peerHost == null) {
- throw new NullPointerException("No null peer host");
+ if (peerAddress == null) {
+ throw new NullPointerException("No null peer address");
}
this.ssl = ssl;
- this.peerHost = peerHost;
- this.host = host;
- this.port = port;
+ this.peerAddress = peerAddress;
+ this.server = server;
}
@Override
@@ -88,15 +87,14 @@ public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EndpointKey that = (EndpointKey) o;
- return ssl == that.ssl && port == that.port && peerHost.equals(that.peerHost) && host.equals(that.host);
+ return ssl == that.ssl && server.equals(that.server) && peerAddress.equals(that.peerAddress);
}
@Override
public int hashCode() {
int result = ssl ? 1 : 0;
- result = 31 * result + peerHost.hashCode();
- result = 31 * result + host.hashCode();
- result = 31 * result + port;
+ result = 31 * result + peerAddress.hashCode();
+ result = 31 * result + server.hashCode();
return result;
}
}
@@ -112,13 +110,22 @@ public Endpoint(Pool pool, Object metric) {
}
}
- void getConnection(ContextInternal ctx, String peerHost, boolean ssl, int port, String host, Handler> handler) {
- EndpointKey key = new EndpointKey(ssl, port, peerHost, host);
+ void getConnection(ContextInternal ctx, SocketAddress peerAddress, boolean ssl, SocketAddress server, Handler> handler) {
+ EndpointKey key = new EndpointKey(ssl, server, peerAddress);
while (true) {
Endpoint endpoint = endpointMap.computeIfAbsent(key, targetAddress -> {
int maxPoolSize = Math.max(client.getOptions().getMaxPoolSize(), client.getOptions().getHttp2MaxPoolSize());
+ String host;
+ int port;
+ if (server.path() == null) {
+ host = server.host();
+ port = server.port();
+ } else {
+ host = server.path();
+ port = 0;
+ }
Object metric = metrics != null ? metrics.createEndpoint(host, port, maxPoolSize) : null;
- HttpChannelConnector connector = new HttpChannelConnector(client, metric, version, ssl, peerHost, host, port);
+ HttpChannelConnector connector = new HttpChannelConnector(client, metric, version, ssl, peerAddress, server);
Pool pool = new Pool<>(ctx, connector, maxWaitQueueSize, connector.weight(), maxSize,
v -> {
if (metrics != null) {
diff --git a/src/main/java/io/vertx/core/http/impl/Http1xClientConnection.java b/src/main/java/io/vertx/core/http/impl/Http1xClientConnection.java
index 55bcb57875c..e140aff333d 100644
--- a/src/main/java/io/vertx/core/http/impl/Http1xClientConnection.java
+++ b/src/main/java/io/vertx/core/http/impl/Http1xClientConnection.java
@@ -35,6 +35,7 @@
import io.vertx.core.impl.logging.Logger;
import io.vertx.core.impl.logging.LoggerFactory;
import io.vertx.core.net.NetSocket;
+import io.vertx.core.net.SocketAddress;
import io.vertx.core.net.impl.ConnectionBase;
import io.vertx.core.net.impl.NetSocketImpl;
import io.vertx.core.net.impl.VertxHandler;
@@ -67,8 +68,7 @@ class Http1xClientConnection extends Http1xConnectionBase impleme
private final HttpClientImpl client;
private final HttpClientOptions options;
private final boolean ssl;
- private final String host;
- private final int port;
+ private final SocketAddress server;
private final Object endpointMetric;
private final HttpClientMetrics metrics;
private final HttpVersion version;
@@ -89,8 +89,7 @@ class Http1xClientConnection extends Http1xConnectionBase impleme
Object endpointMetric,
ChannelHandlerContext channel,
boolean ssl,
- String host,
- int port,
+ SocketAddress server,
ContextInternal context,
HttpClientMetrics metrics) {
super(client.getVertx(), channel, context);
@@ -98,8 +97,7 @@ class Http1xClientConnection extends Http1xConnectionBase impleme
this.client = client;
this.options = client.getOptions();
this.ssl = ssl;
- this.host = host;
- this.port = port;
+ this.server = server;
this.metrics = metrics;
this.version = version;
this.endpointMetric = endpointMetric;
@@ -678,7 +676,7 @@ synchronized void toWebSocket(String requestURI, MultiMap headers, WebsocketVers
URI wsuri = new URI(requestURI);
if (!wsuri.isAbsolute()) {
// Netty requires an absolute url
- wsuri = new URI((ssl ? "https:" : "http:") + "//" + host + ":" + port + requestURI);
+ wsuri = new URI((ssl ? "https:" : "http:") + "//" + server.host() + ":" + server.port() + requestURI);
}
WebSocketVersion version =
WebSocketVersion.valueOf((vers == null ?
diff --git a/src/main/java/io/vertx/core/http/impl/Http2ClientConnection.java b/src/main/java/io/vertx/core/http/impl/Http2ClientConnection.java
index 4369f3461c4..7304517ce4c 100644
--- a/src/main/java/io/vertx/core/http/impl/Http2ClientConnection.java
+++ b/src/main/java/io/vertx/core/http/impl/Http2ClientConnection.java
@@ -174,10 +174,19 @@ public synchronized void onPushPromiseRead(ChannelHandlerContext ctx, int stream
String rawMethod = headers.method().toString();
HttpMethod method = HttpUtils.toVertxMethod(rawMethod);
String uri = headers.path().toString();
- String host = headers.authority() != null ? headers.authority().toString() : null;
+ String authority = headers.authority() != null ? headers.authority().toString() : null;
MultiMap headersMap = new Http2HeadersAdaptor(headers);
Http2Stream promisedStream = handler.connection().stream(promisedStreamId);
- int port = remoteAddress().port();
+ int pos = authority.indexOf(':');
+ int port;
+ String host;
+ if (pos == -1) {
+ host = authority;
+ port = 80;
+ } else {
+ host = authority.substring(0, pos);
+ port = Integer.parseInt(authority.substring(pos + 1));
+ }
HttpClientRequestPushPromise pushReq = new HttpClientRequestPushPromise(this, promisedStream, client, isSsl(), method, rawMethod, uri, host, port, headersMap);
if (metrics != null) {
pushReq.metric(metrics.responsePushed(queueMetric, metric(), localAddress(), remoteAddress(), pushReq));
diff --git a/src/main/java/io/vertx/core/http/impl/HttpChannelConnector.java b/src/main/java/io/vertx/core/http/impl/HttpChannelConnector.java
index 69583885cab..9c7f87105b7 100644
--- a/src/main/java/io/vertx/core/http/impl/HttpChannelConnector.java
+++ b/src/main/java/io/vertx/core/http/impl/HttpChannelConnector.java
@@ -51,18 +51,16 @@ class HttpChannelConnector implements ConnectionProvider {
private final long http2Weight;
private final long http1MaxConcurrency;
private final boolean ssl;
- private final String peerHost;
- private final String host;
- private final int port;
+ private final SocketAddress peerAddress;
+ private final SocketAddress server;
private final Object endpointMetric;
HttpChannelConnector(HttpClientImpl client,
Object endpointMetric,
HttpVersion version,
boolean ssl,
- String peerHost,
- String host,
- int port) {
+ SocketAddress peerAddress,
+ SocketAddress server) {
this.client = client;
this.endpointMetric = endpointMetric;
this.options = client.getOptions();
@@ -80,9 +78,8 @@ class HttpChannelConnector implements ConnectionProvider {
this.weight = version == HttpVersion.HTTP_2 ? http2Weight : http1Weight;
this.http1MaxConcurrency = options.isPipelining() ? options.getPipeliningLimit() : 1;
this.ssl = ssl;
- this.peerHost = peerHost;
- this.host = host;
- this.port = port;
+ this.peerAddress = peerAddress;
+ this.server = server;
}
public long weight() {
@@ -109,20 +106,21 @@ private void doConnect(
ContextInternal context,
Future> future) {
+ boolean domainSocket = server.path() != null;
+ boolean useAlpn = options.isUseAlpn();
+
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(context.nettyEventLoop());
- bootstrap.channelFactory(client.getVertx().transport().channelFactory(false));
+ bootstrap.channelFactory(client.getVertx().transport().channelFactory(domainSocket));
- applyConnectionOptions(false, bootstrap);
-
- boolean useAlpn = options.isUseAlpn();
+ applyConnectionOptions(domainSocket, bootstrap);
ProxyOptions options = this.options.getProxyOptions();
if (options != null && !ssl && options.getType()== ProxyType.HTTP) {
// http proxy requests are handled in HttpClientImpl, everything else can use netty proxy handler
options = null;
}
- ChannelProvider channelProvider = new ChannelProvider(bootstrap, sslHelper, ssl, context, options);
+ ChannelProvider channelProvider = new ChannelProvider(bootstrap, sslHelper, context, options);
Handler> channelHandler = res -> {
if (res.succeeded()) {
@@ -137,25 +135,25 @@ private void doConnect(
applyHttp1xConnectionOptions(ch.pipeline());
HttpVersion fallbackProtocol = "http/1.0".equals(protocol) ?
HttpVersion.HTTP_1_0 : HttpVersion.HTTP_1_1;
- http1xConnected(listener, fallbackProtocol, host, port, true, context, ch, http1Weight, future);
+ http1xConnected(listener, fallbackProtocol, server, true, context, ch, http1Weight, future);
}
} else {
applyHttp1xConnectionOptions(ch.pipeline());
- http1xConnected(listener, version, host, port, true, context, ch, http1Weight, future);
+ http1xConnected(listener, version, server, true, context, ch, http1Weight, future);
}
} else {
ChannelPipeline pipeline = ch.pipeline();
if (version == HttpVersion.HTTP_2) {
if (this.options.isHttp2ClearTextUpgrade()) {
applyHttp1xConnectionOptions(pipeline);
- http1xConnected(listener, version, host, port, false, context, ch, http2Weight, future);
+ http1xConnected(listener, version, server, false, context, ch, http2Weight, future);
} else {
applyHttp2ConnectionOptions(pipeline);
http2Connected(listener, context, ch, future);
}
} else {
applyHttp1xConnectionOptions(pipeline);
- http1xConnected(listener, version, host, port, false, context, ch, http1Weight, future);
+ http1xConnected(listener, version, server, false, context, ch, http1Weight, future);
}
}
} else {
@@ -163,7 +161,8 @@ private void doConnect(
}
};
- channelProvider.connect(SocketAddress.inetSocketAddress(port, host), SocketAddress.inetSocketAddress(port, peerHost), this.options.isForceSni() ? peerHost : null, channelHandler);
+ // SocketAddress.inetSocketAddress(server.port(), peerHost)
+ channelProvider.connect(server, peerAddress, this.options.isForceSni() ? peerAddress.host() : null, ssl, channelHandler);
}
private void applyConnectionOptions(boolean domainSocket, Bootstrap bootstrap) {
@@ -197,15 +196,14 @@ private void applyHttp1xConnectionOptions(ChannelPipeline pipeline) {
private void http1xConnected(ConnectionListener listener,
HttpVersion version,
- String host,
- int port,
+ SocketAddress server,
boolean ssl,
ContextInternal context,
Channel ch, long weight,
Future> future) {
boolean upgrade = version == HttpVersion.HTTP_2 && options.isHttp2ClearTextUpgrade();
VertxHandler clientHandler = VertxHandler.create(context, chctx -> {
- Http1xClientConnection conn = new Http1xClientConnection(listener, upgrade ? HttpVersion.HTTP_1_1 : version, client, endpointMetric, chctx, ssl, host, port, context, metrics);
+ Http1xClientConnection conn = new Http1xClientConnection(listener, upgrade ? HttpVersion.HTTP_1_1 : version, client, endpointMetric, chctx, ssl, server, context, metrics);
if (metrics != null) {
context.executeFromIO(v -> {
Object socketMetric = metrics.connected(conn.remoteAddress(), conn.remoteName());
diff --git a/src/main/java/io/vertx/core/http/impl/HttpClientImpl.java b/src/main/java/io/vertx/core/http/impl/HttpClientImpl.java
index 1f0cf0fe149..6c5a780c8ce 100644
--- a/src/main/java/io/vertx/core/http/impl/HttpClientImpl.java
+++ b/src/main/java/io/vertx/core/http/impl/HttpClientImpl.java
@@ -25,6 +25,7 @@
import io.vertx.core.impl.logging.LoggerFactory;
import io.vertx.core.net.ProxyOptions;
import io.vertx.core.net.ProxyType;
+import io.vertx.core.net.SocketAddress;
import io.vertx.core.net.impl.SSLHelper;
import io.vertx.core.spi.metrics.HttpClientMetrics;
import io.vertx.core.spi.metrics.Metrics;
@@ -84,7 +85,7 @@ public class HttpClientImpl implements HttpClient, MetricsProvider {
if (query != null) {
requestURI += "?" + query;
}
- return Future.succeededFuture(createRequest(m, uri.getHost(), port, ssl, requestURI, null));
+ return Future.succeededFuture(createRequest(m, null, uri.getHost(), port, ssl, requestURI, null));
}
return null;
} catch (Exception e) {
@@ -449,8 +450,13 @@ public WebSocketStream websocketStream(String requestURI, MultiMap headers, Webs
@Override
public HttpClientRequest requestAbs(HttpMethod method, String absoluteURI, Handler> responseHandler) {
+ return requestAbs(method, null, absoluteURI, responseHandler);
+ }
+
+ @Override
+ public HttpClientRequest requestAbs(HttpMethod method, SocketAddress serverAddress, String absoluteURI, Handler> responseHandler) {
Objects.requireNonNull(responseHandler, "no null responseHandler accepted");
- return requestAbs(method, absoluteURI).handler(responseHandler);
+ return requestAbs(method, serverAddress, absoluteURI).handler(responseHandler);
}
@Override
@@ -464,6 +470,12 @@ public HttpClientRequest request(HttpMethod method, int port, String host, Strin
return request(method, port, host, requestURI).handler(responseHandler);
}
+ @Override
+ public HttpClientRequest request(HttpMethod method, SocketAddress serverAddress, int port, String host, String requestURI, Handler> responseHandler) {
+ Objects.requireNonNull(responseHandler, "no null responseHandler accepted");
+ return request(method, serverAddress, port, host, requestURI).handler(responseHandler);
+ }
+
@Override
public HttpClientRequest request(HttpMethod method, String host, String requestURI, Handler> responseHandler) {
return request(method, options.getDefaultPort(), host, requestURI, responseHandler);
@@ -481,6 +493,11 @@ public HttpClientRequest request(HttpMethod method, String requestURI, Handler> responseHandler) {
+ return request(method, serverAddress, options).handler(responseHandler);
+ }
+
+ @Override
+ public HttpClientRequest request(HttpMethod method, SocketAddress serverAddress, RequestOptions options) {
+ return createRequest(method, serverAddress, options.getHost(), options.getPort(), options.isSsl(), options.getURI(), null);
+ }
+
@Override
public HttpClientRequest request(HttpMethod method, RequestOptions options) {
- return createRequest(method, options.getHost(), options.getPort(), options.isSsl(), options.getURI(), null);
+ return createRequest(method, null, options.getHost(), options.getPort(), options.isSsl(), options.getURI(), null);
}
@Override
@@ -948,7 +980,7 @@ private void getConnectionForWebsocket(ContextInternal ctx,
String host,
Handler handler,
Handler connectionExceptionHandler) {
- websocketCM.getConnection(ctx, host, ssl, port, host, ar -> {
+ websocketCM.getConnection(ctx, SocketAddress.inetSocketAddress(port, host), ssl, SocketAddress.inetSocketAddress(port, host), ar -> {
if (ar.succeeded()) {
HttpClientConnection conn = ar.result();
conn.getContext().dispatch(v -> {
@@ -963,12 +995,11 @@ private void getConnectionForWebsocket(ContextInternal ctx,
}
void getConnectionForRequest(ContextInternal ctx,
- String peerHost,
+ SocketAddress peerAddress,
boolean ssl,
- int port,
- String host,
+ SocketAddress server,
Handler> handler) {
- httpCM.getConnection(ctx, peerHost, ssl, port, host, ar -> {
+ httpCM.getConnection(ctx, peerAddress, ssl, server, ar -> {
if (ar.succeeded()) {
ar.result().createStream(ctx, handler);
} else {
@@ -998,15 +1029,15 @@ private URL parseUrl(String surl) {
}
private HttpClient requestNow(HttpMethod method, RequestOptions options, Handler> responseHandler) {
- createRequest(method, options.getHost(), options.getPort(), options.isSsl(), options.getURI(), null).handler(responseHandler).end();
+ createRequest(method, null, options.getHost(), options.getPort(), options.isSsl(), options.getURI(), null).handler(responseHandler).end();
return this;
}
- private HttpClientRequest createRequest(HttpMethod method, String host, int port, Boolean ssl, String relativeURI, MultiMap headers) {
- return createRequest(method, ssl==null || ssl==false ? "http" : "https", host, port, ssl, relativeURI, headers);
+ private HttpClientRequest createRequest(HttpMethod method, SocketAddress serverAddress, String host, int port, Boolean ssl, String relativeURI, MultiMap headers) {
+ return createRequest(method, serverAddress, ssl==null || ssl==false ? "http" : "https", host, port, ssl, relativeURI, headers);
}
- private HttpClientRequest createRequest(HttpMethod method, String protocol, String host, int port, Boolean ssl, String relativeURI, MultiMap headers) {
+ private HttpClientRequest createRequest(HttpMethod method, SocketAddress server, String protocol, String host, int port, Boolean ssl, String relativeURI, MultiMap headers) {
Objects.requireNonNull(method, "no null method accepted");
Objects.requireNonNull(protocol, "no null protocol accepted");
Objects.requireNonNull(host, "no null host accepted");
@@ -1020,8 +1051,8 @@ private HttpClientRequest createRequest(HttpMethod method, String protocol, Stri
HttpClientRequest req;
boolean useProxy = !useSSL && proxyType == ProxyType.HTTP;
if (useProxy) {
- final int defaultPort = protocol.equals("ftp") ? 21 : 80;
- final String addPort = (port != -1 && port != defaultPort) ? (":" + port) : "";
+ int defaultPort = protocol.equals("ftp") ? 21 : 80;
+ String addPort = (port != -1 && port != defaultPort) ? (":" + port) : "";
relativeURI = protocol + "://" + host + addPort + relativeURI;
ProxyOptions proxyOptions = options.getProxyOptions();
if (proxyOptions.getUsername() != null && proxyOptions.getPassword() != null) {
@@ -1031,11 +1062,13 @@ private HttpClientRequest createRequest(HttpMethod method, String protocol, Stri
headers.add("Proxy-Authorization", "Basic " + Base64.getEncoder()
.encodeToString((proxyOptions.getUsername() + ":" + proxyOptions.getPassword()).getBytes()));
}
- req = new HttpClientRequestImpl(this, useSSL, method, proxyOptions.getHost(), proxyOptions.getPort(),
- relativeURI, vertx);
- req.setHost(host + addPort);
+ req = new HttpClientRequestImpl(this, useSSL, method, SocketAddress.inetSocketAddress(proxyOptions.getPort(), proxyOptions.getHost()),
+ host, port, relativeURI, vertx);
} else {
- req = new HttpClientRequestImpl(this, useSSL, method, host, port, relativeURI, vertx);
+ if (server == null) {
+ server = SocketAddress.inetSocketAddress(port, host);
+ }
+ req = new HttpClientRequestImpl(this, useSSL, method, server, host, port, relativeURI, vertx);
}
if (headers != null) {
req.headers().setAll(headers);
diff --git a/src/main/java/io/vertx/core/http/impl/HttpClientRequestBase.java b/src/main/java/io/vertx/core/http/impl/HttpClientRequestBase.java
index aa2e3fdd592..b402108ea30 100644
--- a/src/main/java/io/vertx/core/http/impl/HttpClientRequestBase.java
+++ b/src/main/java/io/vertx/core/http/impl/HttpClientRequestBase.java
@@ -13,6 +13,7 @@
import io.vertx.core.http.HttpClientRequest;
import io.vertx.core.http.HttpMethod;
+import io.vertx.core.net.SocketAddress;
import java.util.concurrent.TimeoutException;
@@ -25,9 +26,10 @@ public abstract class HttpClientRequestBase implements HttpClientRequest {
protected final io.vertx.core.http.HttpMethod method;
protected final String uri;
protected final String path;
+ protected final String query;
protected final String host;
protected final int port;
- protected final String query;
+ protected final SocketAddress server;
protected final boolean ssl;
private long currentTimeoutTimerId = -1;
private long currentTimeoutMs;
@@ -35,10 +37,11 @@ public abstract class HttpClientRequestBase implements HttpClientRequest {
protected Throwable exceptionOccurred;
private Object metric;
- HttpClientRequestBase(HttpClientImpl client, boolean ssl, HttpMethod method, String host, int port, String uri) {
+ HttpClientRequestBase(HttpClientImpl client, boolean ssl, HttpMethod method, SocketAddress server, String host, int port, String uri) {
this.client = client;
this.uri = uri;
this.method = method;
+ this.server = server;
this.host = host;
this.port = port;
this.path = uri.length() > 0 ? HttpUtils.parsePath(uri) : "";
@@ -83,7 +86,7 @@ public String uri() {
}
public String host() {
- return host;
+ return server.host();
}
@Override
@@ -147,7 +150,7 @@ private void handleTimeout(long timeoutMs) {
}
private void timeout(long timeoutMs) {
- String msg = "The timeout period of " + timeoutMs + "ms has been exceeded while executing " + method + " " + uri + " for host " + host;
+ String msg = "The timeout period of " + timeoutMs + "ms has been exceeded while executing " + method + " " + uri + " for server " + server;
// Use a stack-less exception
handleException(new TimeoutException(msg) {
@Override
diff --git a/src/main/java/io/vertx/core/http/impl/HttpClientRequestImpl.java b/src/main/java/io/vertx/core/http/impl/HttpClientRequestImpl.java
index 87f0efc14c1..b44c91d2458 100644
--- a/src/main/java/io/vertx/core/http/impl/HttpClientRequestImpl.java
+++ b/src/main/java/io/vertx/core/http/impl/HttpClientRequestImpl.java
@@ -26,8 +26,9 @@
import io.vertx.core.http.impl.headers.VertxHttpHeaders;
import io.vertx.core.impl.ContextInternal;
import io.vertx.core.impl.VertxInternal;
-import io.vertx.core.impl.logging.Logger;
-import io.vertx.core.impl.logging.LoggerFactory;
+import io.vertx.core.logging.Logger;
+import io.vertx.core.logging.LoggerFactory;
+import io.vertx.core.net.SocketAddress;
import java.util.Objects;
@@ -73,9 +74,10 @@ public class HttpClientRequestImpl extends HttpClientRequestBase implements Http
// completed => drainHandler = null
- HttpClientRequestImpl(HttpClientImpl client, boolean ssl, HttpMethod method, String host, int port,
+ HttpClientRequestImpl(HttpClientImpl client, boolean ssl, HttpMethod method, SocketAddress server,
+ String host, int port,
String relativeURI, VertxInternal vertx) {
- super(client, ssl, method, host, port, relativeURI);
+ super(client, ssl, method, server, host, port, relativeURI);
this.chunked = false;
this.vertx = vertx;
this.priority = HttpUtils.DEFAULT_STREAM_PRIORITY;
@@ -463,16 +465,16 @@ private synchronized void connect(Handler headersHandler) {
throw new IllegalStateException("You must provide a rawMethod when using an HttpMethod.OTHER method");
}
- String peerHost;
+ SocketAddress peerAddress;
if (hostHeader != null) {
int idx = hostHeader.lastIndexOf(':');
if (idx != -1) {
- peerHost = hostHeader.substring(0, idx);
+ peerAddress = SocketAddress.inetSocketAddress(Integer.parseInt(hostHeader.substring(idx + 1)), hostHeader.substring(0, idx));
} else {
- peerHost = hostHeader;
+ peerAddress = SocketAddress.inetSocketAddress(80, hostHeader);
}
} else {
- peerHost = host;
+ peerAddress = SocketAddress.inetSocketAddress(port, host);
}
// Capture some stuff
@@ -493,11 +495,13 @@ private synchronized void connect(Handler headersHandler) {
}
ContextInternal connectCtx = vertx.getOrCreateContext();
+
+
// We defer actual connection until the first part of body is written or end is called
// This gives the user an opportunity to set an exception handler before connecting so
// they can capture any exceptions on connection
connecting = true;
- client.getConnectionForRequest(connectCtx, peerHost, ssl, port, host, ar1 -> {
+ client.getConnectionForRequest(connectCtx, peerAddress, ssl, server, ar1 -> {
if (ar1.succeeded()) {
HttpClientStream stream = ar1.result();
ContextInternal ctx = (ContextInternal) stream.getContext();
diff --git a/src/main/java/io/vertx/core/http/impl/HttpClientRequestPushPromise.java b/src/main/java/io/vertx/core/http/impl/HttpClientRequestPushPromise.java
index 3d88237b16b..ecd020d3575 100644
--- a/src/main/java/io/vertx/core/http/impl/HttpClientRequestPushPromise.java
+++ b/src/main/java/io/vertx/core/http/impl/HttpClientRequestPushPromise.java
@@ -19,6 +19,7 @@
import io.vertx.core.MultiMap;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.*;
+import io.vertx.core.net.SocketAddress;
/**
* @author Julien Viet
@@ -42,7 +43,7 @@ public HttpClientRequestPushPromise(
String host,
int port,
MultiMap headers) {
- super(client, ssl, method, host, port, uri);
+ super(client, ssl, method, SocketAddress.inetSocketAddress(port, host), host, port, uri);
this.conn = conn;
this.stream = new Http2ClientConnection.Http2ClientStream(conn, conn.getContext(), this, stream, false);
this.rawMethod = rawMethod;
@@ -119,7 +120,7 @@ public String uri() {
@Override
public String getHost() {
- return host;
+ return server.host();
}
@Override
diff --git a/src/main/java/io/vertx/core/net/impl/ChannelProvider.java b/src/main/java/io/vertx/core/net/impl/ChannelProvider.java
index 60b00a603a8..fbaa5f12e55 100644
--- a/src/main/java/io/vertx/core/net/impl/ChannelProvider.java
+++ b/src/main/java/io/vertx/core/net/impl/ChannelProvider.java
@@ -43,7 +43,6 @@ public final class ChannelProvider {
private final Bootstrap bootstrap;
private final SSLHelper sslHelper;
- private final boolean ssl;
private final ContextInternal context;
private final ProxyOptions proxyOptions;
private String applicationProtocol;
@@ -51,12 +50,10 @@ public final class ChannelProvider {
public ChannelProvider(Bootstrap bootstrap,
SSLHelper sslHelper,
- boolean ssl,
ContextInternal context,
ProxyOptions proxyOptions) {
this.bootstrap = bootstrap;
this.context = context;
- this.ssl = ssl;
this.sslHelper = sslHelper;
this.proxyOptions = proxyOptions;
}
@@ -75,7 +72,7 @@ public Channel channel() {
return channel;
}
- public void connect(SocketAddress remoteAddress, SocketAddress peerAddress, String serverName, Handler> channelHandler) {
+ public void connect(SocketAddress remoteAddress, SocketAddress peerAddress, String serverName, boolean ssl, Handler> channelHandler) {
Handler> handler = res -> {
if (Context.isOnEventLoopThread()) {
channelHandler.handle(res);
@@ -85,13 +82,13 @@ public void connect(SocketAddress remoteAddress, SocketAddress peerAddress, Stri
}
};
if (proxyOptions != null) {
- handleProxyConnect(remoteAddress, peerAddress, serverName, handler);
+ handleProxyConnect(remoteAddress, peerAddress, serverName, ssl, handler);
} else {
- handleConnect(remoteAddress, peerAddress, serverName, handler);
+ handleConnect(remoteAddress, peerAddress, serverName, ssl, handler);
}
}
- private void initSSL(SocketAddress peerAddress, String serverName, Channel ch, Handler> channelHandler) {
+ private void initSSL(SocketAddress peerAddress, String serverName, boolean ssl, Channel ch, Handler> channelHandler) {
if (ssl) {
SslHandler sslHandler = new SslHandler(sslHelper.createEngine(context.owner(), peerAddress, serverName));
ChannelPipeline pipeline = ch.pipeline();
@@ -124,19 +121,19 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
}
- private void handleConnect(SocketAddress remoteAddress, SocketAddress peerAddress, String serverName, Handler> channelHandler) {
+ private void handleConnect(SocketAddress remoteAddress, SocketAddress peerAddress, String serverName, boolean ssl, Handler> channelHandler) {
VertxInternal vertx = context.owner();
bootstrap.resolver(vertx.nettyAddressResolverGroup());
bootstrap.handler(new ChannelInitializer() {
@Override
protected void initChannel(Channel ch) {
- initSSL(peerAddress, serverName, ch, channelHandler);
+ initSSL(peerAddress, serverName, ssl, ch, channelHandler);
}
});
ChannelFuture fut = bootstrap.connect(vertx.transport().convert(remoteAddress, false));
fut.addListener(res -> {
if (res.isSuccess()) {
- connected(fut.channel(), channelHandler);
+ connected(fut.channel(), ssl, channelHandler);
} else {
channelHandler.handle(io.vertx.core.Future.failedFuture(res.cause()));
}
@@ -149,7 +146,7 @@ protected void initChannel(Channel ch) {
* @param channel the channel
* @param channelHandler the channel handler
*/
- private void connected(Channel channel, Handler> channelHandler) {
+ private void connected(Channel channel, boolean ssl, Handler> channelHandler) {
this.channel = channel;
if (!ssl) {
// No handshake
@@ -160,7 +157,7 @@ private void connected(Channel channel, Handler> channelHan
/**
* A channel provider that connects via a Proxy : HTTP or SOCKS
*/
- private void handleProxyConnect(SocketAddress remoteAddress, SocketAddress peerAddress, String serverName, Handler> channelHandler) {
+ private void handleProxyConnect(SocketAddress remoteAddress, SocketAddress peerAddress, String serverName, boolean ssl, Handler> channelHandler) {
final VertxInternal vertx = context.owner();
final String proxyHost = proxyOptions.getHost();
@@ -206,8 +203,8 @@ public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
if (evt instanceof ProxyConnectionEvent) {
pipeline.remove(proxy);
pipeline.remove(this);
- initSSL(peerAddress, serverName, ch, channelHandler);
- connected(ch, channelHandler);
+ initSSL(peerAddress, serverName, ssl, ch, channelHandler);
+ connected(ch, ssl, channelHandler);
}
ctx.fireUserEventTriggered(evt);
}
diff --git a/src/main/java/io/vertx/core/net/impl/ConnectionBase.java b/src/main/java/io/vertx/core/net/impl/ConnectionBase.java
index e6794183c1c..b5840986987 100644
--- a/src/main/java/io/vertx/core/net/impl/ConnectionBase.java
+++ b/src/main/java/io/vertx/core/net/impl/ConnectionBase.java
@@ -391,22 +391,28 @@ public ChannelPromise channelFuture() {
}
public String remoteName() {
- InetSocketAddress addr = (InetSocketAddress) chctx.channel().remoteAddress();
- if (addr == null) return null;
- // Use hostString that does not trigger a DNS resolution
- return addr.getHostString();
+ java.net.SocketAddress addr = chctx.channel().remoteAddress();
+ if (addr instanceof InetSocketAddress) {
+ // Use hostString that does not trigger a DNS resolution
+ return ((InetSocketAddress)addr).getHostString();
+ }
+ return null;
}
public SocketAddress remoteAddress() {
- InetSocketAddress addr = (InetSocketAddress) chctx.channel().remoteAddress();
- if (addr == null) return null;
- return new SocketAddressImpl(addr);
+ java.net.SocketAddress addr = chctx.channel().remoteAddress();
+ if (addr != null) {
+ return vertx.transport().convert(addr);
+ }
+ return null;
}
public SocketAddress localAddress() {
- InetSocketAddress addr = (InetSocketAddress) chctx.channel().localAddress();
- if (addr == null) return null;
- return new SocketAddressImpl(addr);
+ java.net.SocketAddress addr = chctx.channel().localAddress();
+ if (addr != null) {
+ return vertx.transport().convert(addr);
+ }
+ return null;
}
public void handleMessage(Object msg) {
diff --git a/src/main/java/io/vertx/core/net/impl/NetClientImpl.java b/src/main/java/io/vertx/core/net/impl/NetClientImpl.java
index 3d2ce18d74e..1ba75fedb4b 100644
--- a/src/main/java/io/vertx/core/net/impl/NetClientImpl.java
+++ b/src/main/java/io/vertx/core/net/impl/NetClientImpl.java
@@ -23,8 +23,8 @@
import io.vertx.core.Handler;
import io.vertx.core.impl.ContextInternal;
import io.vertx.core.impl.VertxInternal;
-import io.vertx.core.impl.logging.Logger;
-import io.vertx.core.impl.logging.LoggerFactory;
+import io.vertx.core.logging.Logger;
+import io.vertx.core.logging.LoggerFactory;
import io.vertx.core.net.NetClient;
import io.vertx.core.net.NetClientOptions;
import io.vertx.core.net.NetSocket;
@@ -110,7 +110,7 @@ public synchronized NetClient connect(int port, String host, Handler> connectHandler) {
- doConnect(SocketAddress.inetSocketAddress(port, host), serverName, connectHandler != null ? ar -> connectHandler.handle(ar.map(s -> (NetSocket) s)) : null);
+ doConnect(SocketAddress.inetSocketAddress(port, host), serverName, connectHandler);
return this;
}
@@ -177,7 +177,7 @@ protected void doConnect(SocketAddress remoteAddress, String serverName, Handler
applyConnectionOptions(remoteAddress.path() != null, bootstrap);
- ChannelProvider channelProvider = new ChannelProvider(bootstrap, sslHelper, sslHelper.isSSL(), context, options.getProxyOptions());
+ ChannelProvider channelProvider = new ChannelProvider(bootstrap, sslHelper, context, options.getProxyOptions());
Handler> channelHandler = res -> {
if (res.succeeded()) {
@@ -201,7 +201,7 @@ protected void doConnect(SocketAddress remoteAddress, String serverName, Handler
}
};
- channelProvider.connect(remoteAddress, remoteAddress, serverName, channelHandler);
+ channelProvider.connect(remoteAddress, remoteAddress, serverName, sslHelper.isSSL(), channelHandler);
}
private void connected(ContextInternal context, Channel ch, Handler> connectHandler, SocketAddress remoteAddress) {
diff --git a/src/main/java/io/vertx/core/net/impl/transport/EpollTransport.java b/src/main/java/io/vertx/core/net/impl/transport/EpollTransport.java
index 81ad1aad99a..fecf34e8db0 100644
--- a/src/main/java/io/vertx/core/net/impl/transport/EpollTransport.java
+++ b/src/main/java/io/vertx/core/net/impl/transport/EpollTransport.java
@@ -28,6 +28,7 @@
import io.vertx.core.datagram.DatagramSocketOptions;
import io.vertx.core.net.ClientOptionsBase;
import io.vertx.core.net.NetServerOptions;
+import io.vertx.core.net.impl.SocketAddressImpl;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
@@ -77,6 +78,14 @@ public SocketAddress convert(io.vertx.core.net.SocketAddress address, boolean re
}
}
+ @Override
+ public io.vertx.core.net.SocketAddress convert(SocketAddress address) {
+ if (address instanceof DomainSocketAddress) {
+ return new SocketAddressImpl(((DomainSocketAddress) address).path());
+ }
+ return super.convert(address);
+ }
+
@Override
public boolean isAvailable() {
return Epoll.isAvailable();
diff --git a/src/main/java/io/vertx/core/net/impl/transport/KQueueTransport.java b/src/main/java/io/vertx/core/net/impl/transport/KQueueTransport.java
index f71e483c683..7efcf8613e3 100644
--- a/src/main/java/io/vertx/core/net/impl/transport/KQueueTransport.java
+++ b/src/main/java/io/vertx/core/net/impl/transport/KQueueTransport.java
@@ -22,6 +22,7 @@
import io.netty.channel.unix.DomainSocketAddress;
import io.vertx.core.datagram.DatagramSocketOptions;
import io.vertx.core.net.NetServerOptions;
+import io.vertx.core.net.impl.SocketAddressImpl;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
@@ -48,6 +49,14 @@ public SocketAddress convert(io.vertx.core.net.SocketAddress address, boolean re
}
}
+ @Override
+ public io.vertx.core.net.SocketAddress convert(SocketAddress address) {
+ if (address instanceof DomainSocketAddress) {
+ return new SocketAddressImpl(((DomainSocketAddress) address).path());
+ }
+ return super.convert(address);
+ }
+
@Override
public boolean isAvailable() {
return KQueue.isAvailable();
diff --git a/src/main/java/io/vertx/core/net/impl/transport/Transport.java b/src/main/java/io/vertx/core/net/impl/transport/Transport.java
index bc9a1d7bb61..d0c17e158a8 100644
--- a/src/main/java/io/vertx/core/net/impl/transport/Transport.java
+++ b/src/main/java/io/vertx/core/net/impl/transport/Transport.java
@@ -24,6 +24,7 @@
import io.vertx.core.net.ClientOptionsBase;
import io.vertx.core.net.NetServerOptions;
import io.vertx.core.net.impl.PartialPooledByteBufAllocator;
+import io.vertx.core.net.impl.SocketAddressImpl;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
@@ -114,6 +115,14 @@ public SocketAddress convert(io.vertx.core.net.SocketAddress address, boolean re
}
}
+ public io.vertx.core.net.SocketAddress convert(SocketAddress address) {
+ if (address instanceof InetSocketAddress) {
+ return new SocketAddressImpl((InetSocketAddress) address);
+ } else {
+ return null;
+ }
+ }
+
/**
* Return a channel option for given {@code name} or null if that options does not exist
* for this transport.
diff --git a/src/test/java/io/vertx/core/http/Http1xTLSTest.java b/src/test/java/io/vertx/core/http/Http1xTLSTest.java
index 6280657068e..4322f7d366c 100644
--- a/src/test/java/io/vertx/core/http/Http1xTLSTest.java
+++ b/src/test/java/io/vertx/core/http/Http1xTLSTest.java
@@ -130,7 +130,7 @@ public void testRedirectFromSSL() throws Exception {
req.response().setStatusCode(303).putHeader("location", "http://" + DEFAULT_HTTP_HOST + ":4043/" + DEFAULT_TEST_URI).end();
});
startServer(redirectServer);
- RequestOptions options = new RequestOptions().setHost(DEFAULT_HTTP_HOST).setURI(DEFAULT_TEST_URI).setPort(4043);
+ RequestOptions options = new RequestOptions().setHost(DEFAULT_HTTP_HOST).setURI(DEFAULT_TEST_URI).setPort(4043).setSsl(false);
testTLS(Cert.NONE, Trust.SERVER_JKS, Cert.NONE, Trust.NONE)
.clientSSL(true)
.serverSSL(false)
diff --git a/src/test/java/io/vertx/core/http/Http1xTest.java b/src/test/java/io/vertx/core/http/Http1xTest.java
index 434b3550a46..bd1ada74f72 100644
--- a/src/test/java/io/vertx/core/http/Http1xTest.java
+++ b/src/test/java/io/vertx/core/http/Http1xTest.java
@@ -29,6 +29,7 @@
import io.vertx.test.core.CheckingSender;
import io.vertx.test.verticles.SimpleServer;
import io.vertx.test.core.TestUtils;
+import org.junit.Assume;
import org.junit.Test;
import java.io.File;
@@ -1010,6 +1011,7 @@ public void testCloseHandlerNotCalledWhenConnectionClosedAfterEnd() throws Excep
@Test
public void testTimedOutWaiterDoesntConnect() throws Exception {
+ Assume.assumeTrue("Domain socket don't pass this test", testAddress.path() == null);
long responseDelay = 300;
int requests = 6;
client.close();
@@ -1018,10 +1020,10 @@ public void testTimedOutWaiterDoesntConnect() throws Exception {
// Make sure server is closed before continuing
awaitLatch(firstCloseLatch);
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(false).setMaxPoolSize(1));
+ client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(false).setMaxPoolSize(1));
AtomicInteger requestCount = new AtomicInteger(0);
// We need a net server because we need to intercept the socket connection, not just full http requests
- NetServer server = vertx.createNetServer(new NetServerOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT));
+ NetServer server = vertx.createNetServer();
server.connectHandler(socket -> {
Buffer content = Buffer.buffer();
AtomicBoolean closed = new AtomicBoolean();
@@ -1042,7 +1044,7 @@ public void testTimedOutWaiterDoesntConnect() throws Exception {
CountDownLatch latch = new CountDownLatch(requests);
- server.listen(onSuccess(s -> {
+ server.listen(testAddress, onSuccess(s -> {
for(int count = 0; count < requests; count++) {
RequestOptions reqOptions = new RequestOptions()
@@ -1052,9 +1054,10 @@ public void testTimedOutWaiterDoesntConnect() throws Exception {
HttpClientRequest req;
if (count % 2 == 0) {
- req = client.request(HttpMethod.GET, reqOptions, onSuccess(resp -> {
+ req = client.request(HttpMethod.GET, testAddress, reqOptions, onSuccess(resp -> {
resp.bodyHandler(buff -> {
assertEquals("OK", buff.toString());
+ System.out.println("got resp");
latch.countDown();
});
}));
@@ -1063,7 +1066,8 @@ public void testTimedOutWaiterDoesntConnect() throws Exception {
// Odd requests get a timeout less than the responseDelay, since we have a pool size of one and a delay all but
// the first request should end up in the wait queue, the odd numbered requests should time out so we should get
// (requests + 1 / 2) connect attempts
- req = client.request(HttpMethod.GET, reqOptions, onFailure(err -> {
+ req = client.request(HttpMethod.GET, testAddress, reqOptions, onFailure(err -> {
+ System.out.println("got failure");
latch.countDown();
}));
req.setTimeout(responseDelay / 2);
@@ -1081,7 +1085,7 @@ public void testTimedOutWaiterDoesntConnect() throws Exception {
@Test
public void testPipeliningOrder() throws Exception {
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setPipelining(true).setMaxPoolSize(1));
+ client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(true).setPipelining(true).setMaxPoolSize(1));
int requests = 100;
AtomicInteger reqCount = new AtomicInteger(0);
@@ -1105,11 +1109,11 @@ public void testPipeliningOrder() throws Exception {
CountDownLatch latch = new CountDownLatch(requests);
- server.listen(onSuccess(s -> {
+ server.listen(testAddress, onSuccess(s -> {
vertx.setTimer(500, id -> {
for (int count = 0; count < requests; count++) {
int theCount = count;
- HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(theCount, Integer.parseInt(resp.headers().get("count")));
resp.bodyHandler(buff -> {
assertEquals("This is content " + theCount, buff.toString());
@@ -1163,19 +1167,19 @@ public void testPipeliningLimit() throws Exception {
});
});
CountDownLatch listenLatch = new CountDownLatch(1);
- server.listen(onSuccess(v -> {
+ server.listen(testAddress, onSuccess(v -> {
listenLatch.countDown();
}));
awaitLatch(listenLatch);
AtomicInteger responses = new AtomicInteger();
for (int i = 0;i < requests;i++) {
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
if (responses.incrementAndGet() == requests) {
testComplete();
}
- }));
+ })).end();
}
await();
}
@@ -1189,12 +1193,12 @@ public void testCloseServerConnectionWithPendingMessages() throws Exception {
req.response().close();
});
});
- startServer();
+ startServer(testAddress);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(n).setPipelining(true));
+ client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(n).setPipelining(true));
AtomicBoolean completed = new AtomicBoolean();
for (int i = 0; i < n * 2; i++) {
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(resp -> {
}))
.connectionHandler(conn -> {
conn.closeHandler(v -> {
@@ -1223,7 +1227,7 @@ public void testPipeliningFailure() throws Exception {
req.response().end();
}
});
- startServer();
+ startServer(testAddress);
AtomicInteger succeeded = new AtomicInteger();
List requests = new CopyOnWriteArrayList<>();
Consumer checkEnd = req -> {
@@ -1235,7 +1239,7 @@ public void testPipeliningFailure() throws Exception {
};
for (int i = 0;i < n * 2;i++) {
AtomicReference ref = new AtomicReference<>();
- HttpClientRequest req = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/" + i, ar -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/" + i, ar -> {
if (ar.succeeded()) {
succeeded.incrementAndGet();
}
@@ -1267,10 +1271,10 @@ public void testPipeliningPauseRequest() throws Exception {
req.resume();
});
});
- startServer();
+ startServer(testAddress);
AtomicInteger remaining = new AtomicInteger(n);
for (int i = 0;i < n;i++) {
- HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest req = client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
if (remaining.decrementAndGet() == 0) {
testComplete();
@@ -1300,13 +1304,13 @@ public void testServerPipeliningConnectionConcurrency() throws Exception {
}
});
});
- startServer();
+ startServer(testAddress);
Buffer requests = Buffer.buffer();
for (int i = 0;i < n;i++) {
requests.appendString("GET " + DEFAULT_TEST_URI + " HTTP/1.1\r\n\r\n");
}
NetClient client = vertx.createNetClient();
- client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> {
+ client.connect(testAddress, onSuccess(so -> {
so.closeHandler(v -> testComplete());
so.write(requests);
}));
@@ -1330,7 +1334,7 @@ private void testKeepAlive(boolean keepAlive, int poolSize, int numServers, int
// Make sure server is closed before continuing
awaitLatch(firstCloseLatch);
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(keepAlive).setPipelining(false).setMaxPoolSize(poolSize));
+ client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(keepAlive).setPipelining(false).setMaxPoolSize(poolSize));
int requests = 100;
// Start the servers
@@ -1343,10 +1347,9 @@ private void testKeepAlive(boolean keepAlive, int poolSize, int numServers, int
connectedServers.add(server);
req.response().end();
});
- server.listen(ar -> {
- assertTrue(ar.succeeded());
+ server.listen(testAddress, onSuccess(s -> {
startServerLatch.countDown();
- });
+ }));
servers[i] = server;
}
@@ -1359,7 +1362,7 @@ private void testKeepAlive(boolean keepAlive, int poolSize, int numServers, int
// number of total connections being > pool size (which is correct)
vertx.runOnContext(v -> {
for (int count = 0; count < requests; count++) {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
reqLatch.countDown();
})).end();
@@ -1373,10 +1376,9 @@ private void testKeepAlive(boolean keepAlive, int poolSize, int numServers, int
CountDownLatch serverCloseLatch = new CountDownLatch(numServers);
for (HttpServer server: servers) {
- server.close(ar -> {
- assertTrue(ar.succeeded());
+ server.close(onSuccess(s -> {
serverCloseLatch.countDown();
- });
+ }));
}
awaitLatch(serverCloseLatch);
@@ -1402,7 +1404,11 @@ private void testPooling(boolean keepAlive, boolean pipelining) {
int numGets = 100;
int maxPoolSize = 10;
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(keepAlive).setPipelining(pipelining).setMaxPoolSize(maxPoolSize));
+ client = vertx.createHttpClient(createBaseClientOptions()
+ .setKeepAlive(keepAlive)
+ .setPipelining(pipelining)
+ .setMaxPoolSize(maxPoolSize)
+ );
server.requestHandler(req -> {
String cnt = req.headers().get("count");
@@ -1410,14 +1416,13 @@ private void testPooling(boolean keepAlive, boolean pipelining) {
req.response().end();
});
- AtomicBoolean completeAlready = new AtomicBoolean();
-
- server.listen(onSuccess(s -> {
+ server.listen(testAddress, onSuccess(s -> {
AtomicInteger cnt = new AtomicInteger(0);
for (int i = 0; i < numGets; i++) {
int theCount = i;
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, onSuccess(resp -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, onSuccess(resp -> {
+ resp.exceptionHandler(this::fail);
assertEquals(200, resp.statusCode());
assertEquals(theCount, Integer.parseInt(resp.headers().get("count")));
if (cnt.incrementAndGet() == numGets) {
@@ -1448,7 +1453,7 @@ public void testPoolingNoKeepAliveAndPipelining() {
public void testMaxWaitQueueSizeIsRespected() throws Exception {
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setDefaultHost(DEFAULT_HTTP_HOST).setDefaultPort(DEFAULT_HTTP_PORT)
+ client = vertx.createHttpClient(createBaseClientOptions().setDefaultHost(DEFAULT_HTTP_HOST).setDefaultPort(DEFAULT_HTTP_PORT)
.setPipelining(false).setMaxWaitQueueSize(0).setMaxPoolSize(2));
waitFor(3);
@@ -1459,15 +1464,15 @@ public void testMaxWaitQueueSizeIsRespected() throws Exception {
complete();
});
- startServer();
+ startServer(testAddress);
- HttpClientRequest req1 = client.get("/1", onFailure(err -> {
+ HttpClientRequest req1 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/1", onFailure(err -> {
}));
- HttpClientRequest req2 = client.get("/2", onFailure(resp -> {
+ HttpClientRequest req2 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/2", onFailure(resp -> {
}));
- HttpClientRequest req3 = client.get("/3", onFailure(t -> {
+ HttpClientRequest req3 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/3", onFailure(t -> {
assertTrue("Incorrect exception: " + t.getClass().getName(), t instanceof ConnectionPoolTooBusyException);
complete();
}));
@@ -1498,8 +1503,8 @@ public void testRequestTimeoutExtendedWhenResponseChunksReceived() {
});
});
- server.listen(onSuccess(s -> {
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.endHandler(v -> testComplete());
}));
@@ -1514,7 +1519,7 @@ public void testRequestTimeoutExtendedWhenResponseChunksReceived() {
@Test
public void testServerWebsocketIdleTimeout() {
server.close();
- server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(DEFAULT_HTTP_HOST));
+ server = vertx.createHttpServer(createBaseServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(DEFAULT_HTTP_HOST));
server.websocketHandler(ws -> {}).listen(ar -> {
assertTrue(ar.succeeded());
client.websocket(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", ws -> {
@@ -1543,7 +1548,7 @@ public void testClientWebsocketIdleTimeout() {
public void testSharedServersRoundRobin() throws Exception {
client.close();
server.close();
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(false));
+ client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(false));
int numServers = VertxOptions.DEFAULT_EVENT_LOOP_POOL_SIZE / 2- 1;
int numRequests = numServers * 100;
@@ -1573,9 +1578,11 @@ public void testSharedServersRoundRobin() throws Exception {
requestCount.put(theServer, icnt);
latchConns.countDown();
req.response().end();
- }).listen(onSuccess(s -> {
+ }).listen(testAddress, onSuccess(s -> {
+ if (s.actualPort() > 0) {
assertEquals(DEFAULT_HTTP_PORT, s.actualPort());
- latchListen.countDown();
+ }
+ latchListen.countDown();
}));
}
awaitLatch(latchListen);
@@ -1584,7 +1591,7 @@ public void testSharedServersRoundRobin() throws Exception {
// Create a bunch of connections
CountDownLatch latchClient = new CountDownLatch(numRequests);
for (int i = 0; i < numRequests; i++) {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, res -> latchClient.countDown()).end();
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, res -> latchClient.countDown()).end();
}
assertTrue(latchClient.await(10, TimeUnit.SECONDS));
@@ -1669,9 +1676,9 @@ public void testIncorrectHttpVersion() throws Exception {
so.write(Buffer.buffer("HTTP/1.2 200 OK\r\nContent-Length:5\r\n\r\nHELLO"));
so.close();
});
- startServer();
+ startServer(testAddress);
AtomicBoolean a = new AtomicBoolean();
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {
if (a.compareAndSet(false, true)) {
assertTrue("message " + err.getMessage() + " should contain HTTP/1.2", err.getMessage().contains("HTTP/1.2"));
}
@@ -1695,9 +1702,9 @@ public void testHttp11PersistentConnectionNotClosed() throws Exception {
assertFalse(req.response().closed());
});
- server.listen(onSuccess(s -> {
- client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(true));
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client = vertx.createHttpClient(createBaseClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(true));
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
assertNull(resp.getHeader("Connection"));
assertEquals(resp.getHeader("Content-Length"), "0");
@@ -1721,9 +1728,9 @@ public void testHttp11NonPersistentConnectionClosed() throws Exception {
assertTrue(req.response().closed());
});
- server.listen(onSuccess(s -> {
- client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(false));
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client = vertx.createHttpClient(createBaseClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(false));
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
assertEquals(resp.getHeader("Connection"), "close");
testComplete();
@@ -1746,9 +1753,9 @@ public void testHttp10KeepAliveConnectionNotClosed() throws Exception {
assertFalse(req.response().closed());
});
- server.listen(onSuccess(s -> {
- client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(true));
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client = vertx.createHttpClient(createBaseClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(true));
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
assertEquals(resp.getHeader("Connection"), "keep-alive");
assertEquals(resp.getHeader("Content-Length"), "0");
@@ -1772,9 +1779,9 @@ public void testHttp10RequestNonKeepAliveConnectionClosed() throws Exception {
assertTrue(req.response().closed());
});
- server.listen(onSuccess(s -> {
- client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(false));
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client = vertx.createHttpClient(createBaseClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(false));
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
assertNull(resp.getHeader("Connection"));
testComplete();
@@ -1804,11 +1811,11 @@ public void testHttp10ResponseNonKeepAliveConnectionClosed() throws Exception {
}
});
});
- server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v1 -> {
+ server.listen(testAddress, onSuccess(v1 -> {
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setMaxPoolSize(1));
+ client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(true).setMaxPoolSize(1));
for (int i = 0;i < 3;i++) {
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
resp.endHandler(v2 -> {
complete();
});
@@ -1838,8 +1845,8 @@ public void testAccessNetSocket() throws Exception {
});
});
- server.listen(onSuccess(s -> {
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
assertNotNull(resp.netSocket());
testComplete();
@@ -1867,17 +1874,17 @@ public void testRequestsTimeoutInQueue() {
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(false).setMaxPoolSize(1));
- server.listen(onSuccess(s -> {
+ server.listen(testAddress, onSuccess(s -> {
// Add a few requests that should all timeout
for (int i = 0; i < 5; i++) {
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(t -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(t -> {
assertTrue(t instanceof TimeoutException);
}));
req.setTimeout(500);
req.end();
}
// Now another request that should not timeout
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
testComplete();
}));
@@ -1932,14 +1939,14 @@ public void testClientOptionsCopiedBeforeUse() {
@Test
public void testClientContextWithKeepAlive() throws Exception {
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setPipelining(false).setMaxPoolSize(1));
+ client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(true).setPipelining(false).setMaxPoolSize(1));
testClientContext();
}
@Test
public void testClientContextWithPipelining() throws Exception {
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setPipelining(true).setMaxPoolSize(1));
+ client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(true).setPipelining(true).setMaxPoolSize(1));
testClientContext();
}
@@ -1947,7 +1954,7 @@ private void testClientContext() throws Exception {
server.requestHandler(req -> {
req.response().end();
});
- startServer();
+ startServer(testAddress);
Set contexts = Collections.synchronizedSet(new HashSet<>());
Set connections = Collections.synchronizedSet(new HashSet<>());
Handler> checker = onSuccess(response -> {
@@ -1956,13 +1963,13 @@ private void testClientContext() throws Exception {
contexts.add(current);
connections.add(response.request().connection());
});
- HttpClientRequest req1 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/2", checker)
+ HttpClientRequest req1 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/2", checker)
.exceptionHandler(this::fail);
- HttpClientRequest req2 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/3", checker).exceptionHandler(this::fail);
+ HttpClientRequest req2 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/3", checker).exceptionHandler(this::fail);
CompletableFuture fut = new CompletableFuture<>();
Context ctx = vertx.getOrCreateContext();
ctx.runOnContext(v -> {
- HttpClientRequest req3 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/4", onSuccess(resp -> {
+ HttpClientRequest req3 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/4", onSuccess(resp -> {
// This should warn in the log (console) as we are called back on the connection context
// and not on the context doing the request
// checker.accept(req4);
@@ -1992,9 +1999,9 @@ public void testRequestExceptionHandlerContext() throws Exception {
server.requestHandler(req -> {
req.response().close();
});
- startServer();
+ startServer(testAddress);
Context clientCtx = vertx.getOrCreateContext();
- HttpClientRequest req = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {
assertSameEventLoop(clientCtx, Vertx.currentContext());
complete();
}));
@@ -2062,7 +2069,7 @@ public void testContexts() throws Exception {
}
});
});
- server.listen(onSuccess(s -> {
+ server.listen(testAddress, onSuccess(s -> {
assertSameEventLoop(serverCtx, Vertx.currentContext());
latch.countDown();
}));
@@ -2074,14 +2081,14 @@ public void testContexts() throws Exception {
Set contexts = new ConcurrentHashSet<>();
Set threads = new ConcurrentHashSet<>();
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(numConns));
+ client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(numConns));
Context clientCtx = vertx.getOrCreateContext();
for (int i = 0; i < numReqs; i++) {
int val = i;
CompletableFuture cf = new CompletableFuture<>();
String path = "/" + val;
requestResumeMap.put(path, cf);
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, onSuccess(resp -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, onSuccess(resp -> {
assertSameEventLoop(clientCtx, Vertx.currentContext());
assertEquals(200, resp.statusCode());
contexts.add(Vertx.currentContext());
@@ -2119,14 +2126,13 @@ public void testContexts() throws Exception {
}
awaitLatch(latch2, 40, TimeUnit.SECONDS);
// Close should be in own context
- server.close(ar -> {
- assertTrue(ar.succeeded());
+ server.close(onSuccess(v -> {
ContextInternal closeContext = ((VertxInternal) vertx).getContext();
assertFalse(contexts.contains(closeContext));
assertNotSame(serverCtx, closeContext);
assertFalse(contexts.contains(serverCtx));
testComplete();
- });
+ }));
server = null;
await();
@@ -2137,8 +2143,8 @@ public void testRequestHandlerNotCalledInvalidRequest() {
server.requestHandler(req -> {
fail();
});
- server.listen(onSuccess(s -> {
- vertx.createNetClient(new NetClientOptions()).connect(8080, "127.0.0.1", onSuccess(socket -> {
+ server.listen(testAddress, onSuccess(s -> {
+ vertx.createNetClient(new NetClientOptions()).connect(testAddress, onSuccess(socket -> {
socket.closeHandler(r -> {
testComplete();
});
@@ -2166,9 +2172,8 @@ public void testInWorker() throws Exception {
public void start() throws Exception {
assertTrue(Vertx.currentContext().isWorkerContext());
assertTrue(Context.isOnWorkerThread());
- HttpServer server1 = vertx.createHttpServer(new HttpServerOptions()
- .setHost(HttpTestBase.DEFAULT_HTTP_HOST).setPort(HttpTestBase.DEFAULT_HTTP_PORT));
- server1.requestHandler(req -> {
+ HttpServer server = vertx.createHttpServer();
+ server.requestHandler(req -> {
assertTrue(Vertx.currentContext().isWorkerContext());
assertTrue(Context.isOnWorkerThread());
Buffer buf = Buffer.buffer();
@@ -2177,11 +2182,11 @@ public void start() throws Exception {
assertEquals("hello", buf.toString());
req.response().end("bye");
});
- }).listen(onSuccess(s -> {
+ }).listen(testAddress, onSuccess(s -> {
assertTrue(Vertx.currentContext().isWorkerContext());
assertTrue(Context.isOnWorkerThread());
HttpClient client = vertx.createHttpClient();
- client.put(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/blah", onSuccess(resp -> {
+ client.request(HttpMethod.PUT, testAddress, HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/blah", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
assertTrue(Vertx.currentContext().isWorkerContext());
assertTrue(Context.isOnWorkerThread());
@@ -2215,9 +2220,9 @@ public void testPauseResumeClientResponse() {
}
request.response().end();
});
- server.listen(10000, onSuccess(hs -> {
+ server.listen(testAddress, onSuccess(hs -> {
HttpClient httpClient = vertx.createHttpClient();
- HttpClientRequest clientRequest = httpClient.get(10000, "localhost", "/",
+ HttpClientRequest clientRequest = httpClient.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI,
onSuccess(resp -> {
resp.handler(b -> {
readBuffer.appendBuffer(b);
@@ -2271,8 +2276,8 @@ public void testPauseResumeServerRequestFromAnotherThread() throws Exception {
testComplete();
});
});
- startServer();
- HttpClientRequest req = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, "/", onFailure(err -> {}));
+ startServer(testAddress);
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, DEFAULT_TEST_URI, onFailure(err -> {}));
req.setChunked(true);
for (int i = 0; i < buffer.length() / 8192; i++) {
req.write(buffer.slice(i * 8192, (i + 1) * 8192));
@@ -2289,18 +2294,18 @@ public void testEndServerResponseResumeTheConnection() throws Exception {
req.response().end();
});
});
- startServer();
+ startServer(testAddress);
client.close();
waitFor(2);
client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setMaxPoolSize(1));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
complete();
- }));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ })).end();
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
complete();
- }));
+ })).end();
await();
}
@@ -2312,15 +2317,15 @@ public void testEndServerRequestResumeTheConnection() throws Exception {
req.pause();
});
});
- startServer();
+ startServer(testAddress);
client.close();
waitFor(2);
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setMaxPoolSize(1));
- client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(true).setMaxPoolSize(1));
+ client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
complete();
})).end("1");
- client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
complete();
})).end("2");
@@ -2334,12 +2339,11 @@ public void testMultipleRecursiveCallsAndPipelining() throws Exception {
server.requestHandler(x -> {
x.response().end("hello");
})
- .listen(8080, r -> {
+ .listen(testAddress, r -> {
if (r.succeeded()) {
- HttpClient client = vertx.createHttpClient(new HttpClientOptions()
+ HttpClient client = vertx.createHttpClient(createBaseClientOptions()
.setKeepAlive(true)
.setPipelining(true)
- .setDefaultPort(8080)
);
IntStream.range(0, 5).forEach(i -> recursiveCall(client, receivedRequests, sendRequests));
}
@@ -2348,14 +2352,14 @@ public void testMultipleRecursiveCallsAndPipelining() throws Exception {
}
private void recursiveCall(HttpClient client, AtomicInteger receivedRequests, int sendRequests){
- client.getNow("/", r -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, DEFAULT_TEST_URI, r -> {
int numRequests = receivedRequests.incrementAndGet();
if (numRequests == sendRequests) {
testComplete();
} else if (numRequests < sendRequests) {
recursiveCall(client, receivedRequests, sendRequests);
}
- });
+ }).end();
}
@Test
@@ -2377,23 +2381,21 @@ private void testUnsupported(String rawReq, boolean method) throws Exception {
// OK
}
})
- .listen(8080, r -> {
- if (r.succeeded()) {
- NetClient client = vertx.createNetClient();
- // Send a raw request
- client.connect(8080, "localhost", onSuccess(conn -> {
- conn.write(rawReq);
- Buffer respBuff = Buffer.buffer();
- conn.handler(respBuff::appendBuffer);
- conn.closeHandler(v -> {
- // Server should automatically close it after sending back 501
- assertTrue(respBuff.toString().contains("501 Not Implemented"));
- client.close();
- testComplete();
- });
- }));
- }
- });
+ .listen(testAddress, onSuccess(s -> {
+ NetClient client = vertx.createNetClient();
+ // Send a raw request
+ client.connect(testAddress, onSuccess(conn -> {
+ conn.write(rawReq);
+ Buffer respBuff = Buffer.buffer();
+ conn.handler(respBuff::appendBuffer);
+ conn.closeHandler(v -> {
+ // Server should automatically close it after sending back 501
+ assertTrue(respBuff.toString().contains("501 Not Implemented"));
+ client.close();
+ testComplete();
+ });
+ }));
+ }));
await();
}
@@ -2405,24 +2407,27 @@ public void testTwoServersDifferentEventLoopsCloseOne() throws Exception {
server.requestHandler(req -> {
server1Count.incrementAndGet();
req.response().end();
- }).listen(8080, onSuccess(s -> {
+ }).listen(testAddress, onSuccess(s -> {
latch1.countDown();
}));
HttpServer server2 = vertx.createHttpServer().requestHandler(req -> {
server2Count.incrementAndGet();
req.response().end();
- }).listen(8080, onSuccess(s -> {
+ }).listen(testAddress, onSuccess(s -> {
latch1.countDown();
}));
awaitLatch(latch1);
- HttpClient client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(false).setDefaultPort(8080));
+ HttpClient[] clients = new HttpClient[5];
+ for (int i = 0;i < 5;i++) {
+ clients[i] = vertx.createHttpClient(createBaseClientOptions());
+ }
for (int i = 0; i < 2; i++) {
CountDownLatch latch2 = new CountDownLatch(1);
- client.getNow("/", onSuccess(resp -> {
+ clients[i].request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
latch2.countDown();
- }));
+ })).end();
awaitLatch(latch2);
}
@@ -2435,10 +2440,10 @@ public void testTwoServersDifferentEventLoopsCloseOne() throws Exception {
// Send some more requests
for (int i = 0; i < 2; i++) {
CountDownLatch latch2 = new CountDownLatch(1);
- client.getNow("/", onSuccess(resp -> {
+ clients[2 + i].request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
latch2.countDown();
- }));
+ })).end();
awaitLatch(latch2);
}
@@ -2459,11 +2464,11 @@ public void testSetWriteQueueMaxSize() throws Exception {
resp.setWriteQueueMaxSize(128 * 1024);
resp.setWriteQueueMaxSize(129 * 1024);
resp.end();
- }).listen(8080, onSuccess(s -> {
- client.getNow(8080, "localhost", "/", onSuccess(resp -> {
+ }).listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
testComplete();
- }));
+ })).end();
}));
await();
}
@@ -2482,13 +2487,13 @@ public void testServerMaxInitialLineLengthOption() {
private void testServerMaxInitialLineLength(int maxInitialLength) {
String longParam = TestUtils.randomAlphaString(5000);
server.close();
- server = vertx.createHttpServer(new HttpServerOptions().setMaxInitialLineLength(maxInitialLength)
- .setHost("localhost").setPort(8080)).requestHandler(req -> {
+ server = vertx.createHttpServer(createBaseServerOptions().setMaxInitialLineLength(maxInitialLength))
+ .requestHandler(req -> {
assertEquals(req.getParam("t"), longParam);
req.response().end();
- }).listen(onSuccess(res -> {
- HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions())
- .request(HttpMethod.GET, 8080, "localhost", "/?t=" + longParam,
+ }).listen(testAddress, onSuccess(res -> {
+ HttpClientRequest req = vertx.createHttpClient()
+ .request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/?t=" + longParam,
onSuccess(resp -> {
if (maxInitialLength > HttpServerOptions.DEFAULT_MAX_INITIAL_LINE_LENGTH) {
assertEquals(200, resp.statusCode());
@@ -2524,9 +2529,9 @@ public void testClientMaxInitialLineLengthOption() {
// 5017 = 5000 for longParam and 17 for the rest in the following line - "GET /?t=longParam HTTP/1.1"
try {
- server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, onSuccess(v -> {
+ server.listen(testAddress, onSuccess(v -> {
vertx.createHttpClient(new HttpClientOptions().setMaxInitialLineLength(6000))
- .request(HttpMethod.GET, 8080, "localhost", "/?t=" + longParam, onSuccess(resp -> {
+ .request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/?t=" + longParam, onSuccess(resp -> {
resp.bodyHandler(body -> {
assertEquals("0123456789", body.toString());
testComplete();
@@ -2545,12 +2550,12 @@ public void testClientMaxHeaderSizeOption() {
String longHeader = TestUtils.randomAlphaString(9000);
// min 9023 = 9000 for longHeader and 23 for "Content-Length: 0 t: "
- vertx.createHttpServer(new HttpServerOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> {
+ vertx.createHttpServer(createBaseServerOptions()).requestHandler(req -> {
// Add longHeader
req.response().putHeader("t", longHeader).end();
- }).listen(onSuccess(res -> {
+ }).listen(testAddress, onSuccess(res -> {
HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions().setMaxHeaderSize(10000))
- .request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
+ .request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
assertEquals(resp.getHeader("t"), longHeader);
testComplete();
@@ -2576,13 +2581,13 @@ private void testServerMaxHeaderSize(int maxHeaderSize) {
String longHeader = TestUtils.randomAlphaString(9000);
- vertx.createHttpServer(new HttpServerOptions().setMaxHeaderSize(maxHeaderSize)
- .setHost("localhost").setPort(8080)).requestHandler(req -> {
+ vertx.createHttpServer(createBaseServerOptions().setMaxHeaderSize(maxHeaderSize))
+ .requestHandler(req -> {
assertEquals(req.getHeader("t"), longHeader);
req.response().end();
- }).listen(onSuccess(res -> {
+ }).listen(testAddress, onSuccess(res -> {
HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions())
- .request(HttpMethod.GET, 8080, "localhost", "/",
+ .request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI,
onSuccess(resp -> {
if (maxHeaderSize > HttpServerOptions.DEFAULT_MAX_HEADER_SIZE) {
assertEquals(200, resp.statusCode());
@@ -2636,13 +2641,13 @@ public void testInvalidHttpResponse() {
}
}
});
- }).listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(s -> {
+ }).listen(testAddress, onSuccess(s -> {
// We force two pipelined requests to check that the second request does not get stuck after the first failing
- client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setPipelining(true).setMaxPoolSize(1));
+ client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(true).setPipelining(true).setMaxPoolSize(1));
AtomicBoolean fail1 = new AtomicBoolean();
- HttpClientRequest req1 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {
+ HttpClientRequest req1 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {
if (fail1.compareAndSet(false, true)) {
assertEquals(IllegalArgumentException.class, err.getClass()); // invalid version format
complete();
@@ -2650,7 +2655,7 @@ public void testInvalidHttpResponse() {
}));
AtomicBoolean fail2 = new AtomicBoolean();
- HttpClientRequest req2 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {
+ HttpClientRequest req2 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {
if (fail2.compareAndSet(false, true)) {
assertEquals(IllegalArgumentException.class, err.getClass()); // Closed
complete();
@@ -2673,10 +2678,10 @@ public void testHandleInvalid204Response() throws Exception {
server.requestHandler(r -> {
// Generate an invalid response for the pipe-lined
r.response().setChunked(true).setStatusCode(204).end();
- }).listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v1 -> {
+ }).listen(testAddress, onSuccess(v1 -> {
for (int i = 0;i < numReq;i++) {
AtomicInteger count = new AtomicInteger();
- HttpClientRequest post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath",
+ HttpClientRequest post = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI,
onSuccess(r -> {
r.endHandler(v2 -> {
complete();
@@ -2701,11 +2706,11 @@ public void testConnectionCloseHttp_1_0_NoClose() throws Exception {
AtomicBoolean firstRequest = new AtomicBoolean(true);
socket.handler(RecordParser.newDelimited("\r\n\r\n", buffer -> {
if (firstRequest.getAndSet(false)) {
- socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 4\n"
- + "Connection: keep-alive\n" + "\n" + "xxx\n");
+ socket.write("HTTP/1.0 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 4\r\n"
+ + "Connection: keep-alive\r\n" + "\r\n" + "xxx\n");
} else {
- socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 1\n"
- + "\n" + "\n");
+ socket.write("HTTP/1.0 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 1\r\n"
+ + "\r\n" + "\n");
}
}));
});
@@ -2720,11 +2725,11 @@ public void testConnectionCloseHttp_1_0_Close() throws Exception {
AtomicBoolean firstRequest = new AtomicBoolean(true);
socket.handler(RecordParser.newDelimited("\r\n\r\n", buffer -> {
if (firstRequest.getAndSet(false)) {
- socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 4\n"
- + "Connection: keep-alive\n" + "\n" + "xxx\n");
+ socket.write("HTTP/1.0 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 4\r\n"
+ + "Connection: keep-alive\r\n" + "\n" + "xxx\n");
} else {
- socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 1\n"
- + "\n" + "\n");
+ socket.write("HTTP/1.0 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 1\r\n"
+ + "\r\n" + "\n");
socket.close();
}
}));
@@ -2741,7 +2746,7 @@ public void testConnectionCloseHttp_1_1_NoClose() throws Exception {
+ "\r\n" + "xxx\n");
} else {
socket.write("HTTP/1.1 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 1\r\n"
- + "Connection: close\r\n" + "\r\n" + "\r\n");
+ + "Connection: close\r\n" + "\r\n" + "\n");
}
}));
});
@@ -2756,8 +2761,8 @@ public void testConnectionCloseHttp_1_1_Close() throws Exception {
socket.write("HTTP/1.1 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 3\r\n"
+ "\r\n" + "xxx");
} else {
- socket.write("HTTP/1.1 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 0\r\n"
- + "Connection: close\r\n" + "\r\n");
+ socket.write("HTTP/1.1 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 1\r\n"
+ + "Connection: close\r\n" + "\r\n" + "\n");
socket.close();
}
}));
@@ -2768,6 +2773,8 @@ private void testConnectionClose(
Handler clientRequest,
Handler connectHandler
) throws Exception {
+ // Cannot reliably pass due to https://github.com/netty/netty/issues/9113
+ Assume.assumeTrue(testAddress.path() == null);
client.close();
server.close();
@@ -2775,7 +2782,7 @@ private void testConnectionClose(
NetServerOptions serverOptions = new NetServerOptions();
CountDownLatch serverLatch = new CountDownLatch(1);
- vertx.createNetServer(serverOptions).connectHandler(connectHandler).listen(8080, result -> {
+ vertx.createNetServer(serverOptions).connectHandler(connectHandler).listen(testAddress, result -> {
if (result.succeeded()) {
serverLatch.countDown();
} else {
@@ -2787,7 +2794,6 @@ private void testConnectionClose(
HttpClientOptions clientOptions = new HttpClientOptions()
.setDefaultHost("localhost")
- .setDefaultPort(8080)
.setKeepAlive(true)
.setPipelining(false);
client = vertx.createHttpClient(clientOptions);
@@ -2796,7 +2802,7 @@ private void testConnectionClose(
AtomicInteger count = new AtomicInteger(requests);
for (int i = 0; i < requests; i++) {
- HttpClientRequest req = client.get("/", onSuccess(resp -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.handler(buffer -> {
// Should check
});
@@ -2805,12 +2811,8 @@ private void testConnectionClose(
complete();
}
});
- resp.exceptionHandler(th -> {
- fail();
- });
- })).exceptionHandler(th -> {
- fail();
- });
+ resp.exceptionHandler(this::fail);
+ }));
clientRequest.handle(req);
}
@@ -2824,14 +2826,9 @@ public void testDontReuseConnectionWhenResponseEndsDuringAnOngoingRequest() thro
server.requestHandler(req -> {
req.response().end();
});
- CountDownLatch serverLatch = new CountDownLatch(1);
- server.listen(ar -> {
- assertTrue(ar.succeeded());
- serverLatch.countDown();
- });
+ startServer(testAddress);
- awaitLatch(serverLatch);
- HttpClientRequest req1 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/",
+ HttpClientRequest req1 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI,
onSuccess(resp -> {
resp.endHandler(v1 -> {
// End request after the response ended
@@ -2860,26 +2857,26 @@ public void testRecyclePipelinedConnection() throws Exception {
req.response().end();
doneLatch.countDown();
});
- server.listen(onSuccess(s -> {
+ server.listen(testAddress, onSuccess(s -> {
listenLatch.countDown();
}));
awaitLatch(listenLatch);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setPipelining(true).setKeepAlive(true));
+ client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1).setPipelining(true).setKeepAlive(true));
AtomicInteger connCount = new AtomicInteger();
client.connectionHandler(conn -> connCount.incrementAndGet());
- HttpClientRequest req = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/first", onSuccess(resp -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/first", onSuccess(resp -> {
fail();
}));
req.reset(0);
CountDownLatch respLatch = new CountDownLatch(2);
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/second", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/second", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.endHandler(v -> {
respLatch.countDown();
});
})).exceptionHandler(this::fail).end();
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/third", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/third", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.endHandler(v -> {
respLatch.countDown();
@@ -2898,10 +2895,8 @@ public void testClientConnectionExceptionHandler() throws Exception {
NetSocket so = req.netSocket();
so.write(Buffer.buffer(TestUtils.randomAlphaString(40) + "\r\n"));
});
- CountDownLatch listenLatch = new CountDownLatch(1);
- server.listen(onSuccess(s -> listenLatch.countDown()));
- awaitLatch(listenLatch);
- HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> {
+ startServer(testAddress);
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> {
});
req.connectionHandler(conn -> {
conn.exceptionHandler(err -> {
@@ -2923,17 +2918,15 @@ public void testServerConnectionExceptionHandler() throws Exception {
server.requestHandler(req -> {
req.response().end();
});
- CountDownLatch listenLatch = new CountDownLatch(1);
- server.listen(onSuccess(s -> listenLatch.countDown()));
- awaitLatch(listenLatch);
+ startServer(testAddress);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp1 -> {
- HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp2 -> {
+ client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1));
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp1 -> {
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp2 -> {
});
req.putHeader("the_header", TestUtils.randomAlphaString(10000));
req.sendHead();
- });
+ }).end();
await();
}
@@ -2946,10 +2939,8 @@ public void testServerExceptionHandler() throws Exception {
server.requestHandler(req -> {
fail();
});
- CountDownLatch listenLatch = new CountDownLatch(1);
- server.listen(onSuccess(s -> listenLatch.countDown()));
- awaitLatch(listenLatch);
- HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> {
+ startServer(testAddress);
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> {
});
req.putHeader("the_header", TestUtils.randomAlphaString(10000));
req.sendHead();
@@ -2957,7 +2948,7 @@ public void testServerExceptionHandler() throws Exception {
}
@Test
- public void testRandomPorts() throws Exception {
+ public void testRandomPorts() {
int numServers = 10;
Set ports = Collections.synchronizedSet(new HashSet<>());
AtomicInteger count = new AtomicInteger();
@@ -2992,9 +2983,9 @@ public void testContentDecompression() throws Exception {
});
});
- server.listen(onSuccess(server -> {
+ server.listen(testAddress, onSuccess(server -> {
client
- .request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> testComplete()))
+ .request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> testComplete()))
.putHeader("Content-Encoding", "gzip")
.end(Buffer.buffer(dataGzipped));
}));
@@ -3038,24 +3029,24 @@ private void testResetClientRequestNotYetSent(boolean keepAlive, boolean pipelin
});
});
CountDownLatch latch = new CountDownLatch(1);
- server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> {
+ server.listen(testAddress, onSuccess(v -> {
latch.countDown();
}));
awaitLatch(latch);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setKeepAlive(keepAlive).setPipelining(pipelined));
+ client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1).setKeepAlive(keepAlive).setPipelining(pipelined));
// There might be a race between the request write and the request reset
// so we do it on the context thread to avoid it
vertx.runOnContext(v -> {
- HttpClientRequest post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest post = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
fail();
}));
post.setChunked(true).write(TestUtils.randomBuffer(1024));
assertTrue(post.reset());
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
assertEquals(1, numReq.get());
complete();
- });
+ }).end();
});
await();
} finally {
@@ -3091,14 +3082,14 @@ public void testResetKeepAliveClientRequest() throws Exception {
});
});
CountDownLatch listenLatch = new CountDownLatch(1);
- server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> {
+ server.listen(testAddress, onSuccess(v -> {
listenLatch.countDown();
}));
awaitLatch(listenLatch);
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setPipelining(false).setKeepAlive(true));
AtomicInteger status = new AtomicInteger();
- HttpClientRequest req1 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> {
+ HttpClientRequest req1 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> {
assertEquals(0, status.getAndIncrement());
});
req1.connectionHandler(conn -> {
@@ -3108,7 +3099,7 @@ public void testResetKeepAliveClientRequest() throws Exception {
});
});
req1.end();
- HttpClientRequest req2 = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> complete()));
+ HttpClientRequest req2 = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> complete()));
req2.sendHead(v -> {
assertTrue(req2.reset());
});
@@ -3151,13 +3142,13 @@ public void testResetPipelinedClientRequest() throws Exception {
});
try {
CountDownLatch listenLatch = new CountDownLatch(1);
- server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> {
+ server.listen(testAddress, onSuccess(v -> {
listenLatch.countDown();
}));
awaitLatch(listenLatch);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setPipelining(true).setKeepAlive(true));
- HttpClientRequest req1 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", ar -> {
+ client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1).setPipelining(true).setKeepAlive(true));
+ HttpClientRequest req1 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", ar -> {
// We may or not receive the response
});
req1.connectionHandler(conn -> {
@@ -3166,7 +3157,7 @@ public void testResetPipelinedClientRequest() throws Exception {
});
});
req1.end();
- HttpClientRequest req2 = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(resp -> {
+ HttpClientRequest req2 = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(resp -> {
}));
req2.sendHead();
doReset.thenAccept(v -> {
@@ -3233,22 +3224,22 @@ private void testCloseTheConnectionAfterResetPersistentClientRequest(boolean pip
}
});
CountDownLatch listenLatch = new CountDownLatch(1);
- server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> {
+ server.listen(testAddress, onSuccess(v -> {
listenLatch.countDown();
}));
awaitLatch(listenLatch);
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setPipelining(pipelined).setKeepAlive(true));
- HttpClientRequest req1 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {}));
+ HttpClientRequest req1 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {}));
if (pipelined) {
req1.connectionHandler(conn -> conn.closeHandler(v2 -> {
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.bodyHandler(body -> {
assertEquals("Hello world", body.toString());
complete();
});
- }));
+ })).end();
}));
req1.sendHead(v -> {
assertTrue(req1.reset());
@@ -3257,13 +3248,13 @@ private void testCloseTheConnectionAfterResetPersistentClientRequest(boolean pip
req1.sendHead(v -> {
assertTrue(req1.reset());
});
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.bodyHandler(body -> {
assertEquals("Hello world", body.toString());
complete();
});
- }));
+ })).end();
}
await();
} finally {
@@ -3332,20 +3323,20 @@ private void testCloseTheConnectionAfterResetPersistentClientResponse(boolean pi
}
});
CountDownLatch listenLatch = new CountDownLatch(1);
- server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> {
+ server.listen(testAddress, onSuccess(v -> {
listenLatch.countDown();
}));
awaitLatch(listenLatch);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setPipelining(pipelined).setKeepAlive(true));
+ client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1).setPipelining(pipelined).setKeepAlive(true));
if (pipelined) {
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath",
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath",
onSuccess(resp1 -> {
resp1.handler(buff -> {
resp1.request().reset();
// Since we pipeline we must be sure that the first request is closed before running a new one
resp1.request().connection().closeHandler(v -> {
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.bodyHandler(body -> {
assertEquals("Hello world", body.toString());
@@ -3354,21 +3345,21 @@ private void testCloseTheConnectionAfterResetPersistentClientResponse(boolean pi
})).end();
});
});
- }));
+ })).end();
} else {
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath",
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath",
onSuccess(resp -> {
resp.handler(buff -> {
resp.request().reset();
});
- }));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
+ })).end();
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.bodyHandler(body -> {
assertEquals("Hello world", body.toString());
complete();
});
- }));
+ })).end();
}
await();
} finally {
@@ -3439,25 +3430,25 @@ private void testCloseTheConnectionAfterResetBeforeResponseReceived(boolean pipe
}
});
CountDownLatch listenLatch = new CountDownLatch(1);
- server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> {
+ server.listen(testAddress, onSuccess(v -> {
listenLatch.countDown();
}));
awaitLatch(listenLatch);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setPipelining(pipelined).setKeepAlive(true));
- HttpClientRequest req1 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/1", onFailure(err -> {}));
+ client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1).setPipelining(pipelined).setKeepAlive(true));
+ HttpClientRequest req1 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/1", onFailure(err -> {}));
if (pipelined) {
requestReceived.thenAccept(v -> {
req1.reset();
});
req1.connectionHandler(conn -> conn.closeHandler(v2 -> {
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/2", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/2", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.bodyHandler(body -> {
assertEquals("Hello world", body.toString());
complete();
});
- }));
+ })).end();
}));
req1.end();
} else {
@@ -3465,13 +3456,13 @@ private void testCloseTheConnectionAfterResetBeforeResponseReceived(boolean pipe
req1.reset();
});
req1.end();
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/2", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/2", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.bodyHandler(body -> {
assertEquals("Hello world", body.toString());
complete();
});
- }));
+ })).end();
}
await();
} finally {
@@ -3490,10 +3481,10 @@ public void testTooLongContentInHttpServerRequest() throws Exception {
testComplete();
});
});
- startServer();
+ startServer(testAddress);
NetClient client = vertx.createNetClient();
try {
- client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> {
+ client.connect(testAddress, onSuccess(so -> {
so.write("POST / HTTP/1.1\r\nContent-Length: 4\r\n\r\ntoolong\r\n");
}));
await();
@@ -3539,9 +3530,9 @@ private void testHttpServerRequestDecodeError(Handler bodySender, Han
req.exceptionHandler(handler);
bodySender.handle(current.get());
});
- startServer();
+ startServer(testAddress);
NetClient client = vertx.createNetClient();
- client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> {
+ client.connect(testAddress, onSuccess(so -> {
current.set(so);
so.write("POST /somepath HTTP/1.1\r\n");
so.write("Transfer-Encoding: chunked\r\n");
@@ -3603,10 +3594,10 @@ public void testInvalidTrailersInHttpClientResponse() throws Exception {
}
private void testHttpClientResponseDecodeError(Handler errorHandler) throws Exception {
- startServer();
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
resp.exceptionHandler(errorHandler);
- }));
+ })).end();
await();
}
@@ -3617,14 +3608,14 @@ public void testRequestTimeoutIsNotDelayedAfterResponseIsReceived() throws Excep
server.requestHandler(req -> {
req.response().end();
});
- startServer();
+ startServer(testAddress);
vertx.deployVerticle(new AbstractVerticle() {
@Override
public void start() throws Exception {
HttpClient client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(n));
for (int i = 0;i < n;i++) {
AtomicBoolean responseReceived = new AtomicBoolean();
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
try {
Thread.sleep(150);
} catch (InterruptedException e) {
@@ -3730,10 +3721,10 @@ public void testSendFileFailsWhenClientClosesConnection() throws Exception {
fail(e);
}
});
- startServer();
- vertx.createNetClient().connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, socket -> {
- socket.result().write("GET / HTTP/1.1\r\n\r\n").close();
- });
+ startServer(testAddress);
+ vertx.createNetClient().connect(testAddress, onSuccess(socket -> {
+ socket.write("GET / HTTP/1.1\r\n\r\n").close();
+ }));
await();
}
@@ -3745,11 +3736,11 @@ protected MultiMap checkEmptyHttpResponse(HttpMethod method, int sc, MultiMap re
resp.headers().addAll(reqHeaders);
resp.end();
});
- startServer();
+ startServer(testAddress);
NetClient client = vertx.createNetClient();
try {
CompletableFuture result = new CompletableFuture<>();
- client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, ar -> {
+ client.connect(testAddress, ar -> {
if (ar.succeeded()) {
NetSocket so = ar.result();
so.write(
@@ -3793,13 +3784,13 @@ public void testUnknownContentLengthIsSetToZeroWithHTTP_1_0() throws Exception {
server.requestHandler(req -> {
req.response().write("Some-String").end();
});
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertNull(resp.getHeader("Content-Length"));
testComplete();
- }));
+ })).end();
await();
}
@@ -3810,9 +3801,9 @@ public void testPartialH2CAmbiguousRequest() throws Exception {
testComplete();
});
Buffer fullRequest = Buffer.buffer("POST /whatever HTTP/1.1\r\n\r\n");
- startServer();
+ startServer(testAddress);
NetClient client = vertx.createNetClient();
- client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> {
+ client.connect(testAddress, onSuccess(so -> {
so.write(fullRequest.slice(0, 1));
vertx.setTimer(1000, id -> {
so.write(fullRequest.slice(1, fullRequest.length()));
@@ -3831,9 +3822,9 @@ public void testIdleTimeoutWithPartialH2CRequest() throws Exception {
server.requestHandler(req -> {
testComplete();
});
- startServer();
+ startServer(testAddress);
NetClient client = vertx.createNetClient();
- client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> {
+ client.connect(testAddress, onSuccess(so -> {
so.closeHandler(v -> {
testComplete();
});
@@ -3844,16 +3835,13 @@ public void testIdleTimeoutWithPartialH2CRequest() throws Exception {
@Test
public void testIdleTimeoutInfiniteSkipOfControlCharactersState() throws Exception {
server.close();
- server = vertx.createHttpServer(new HttpServerOptions()
- .setPort(DEFAULT_HTTP_PORT)
- .setHost(DEFAULT_HTTP_HOST)
- .setIdleTimeout(1));
+ server = vertx.createHttpServer(createBaseServerOptions().setIdleTimeout(1));
server.requestHandler(req -> {
testComplete();
});
- startServer();
+ startServer(testAddress);
NetClient client = vertx.createNetClient();
- client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> {
+ client.connect(testAddress, onSuccess(so -> {
long id = vertx.setPeriodic(1, timerID -> {
so.write(Buffer.buffer().setInt(0, 0xD));
});
@@ -3869,15 +3857,12 @@ public void testIdleTimeoutInfiniteSkipOfControlCharactersState() throws Excepti
public void testCompressedResponseWithConnectionCloseAndNoCompressionHeader() throws Exception {
Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(2048));
server.close();
- server = vertx.createHttpServer(new HttpServerOptions()
- .setPort(DEFAULT_HTTP_PORT)
- .setHost(DEFAULT_HTTP_HOST)
- .setCompressionSupported(true));
+ server = vertx.createHttpServer(createBaseServerOptions().setCompressionSupported(true));
server.requestHandler(req -> {
req.response().end(expected);
});
- startServer();
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.bodyHandler(buff -> {
assertEquals(expected, buff);
complete();
@@ -3938,13 +3923,13 @@ public void testKeepAliveTimeoutHeaderOverwritePrevious() throws Exception {
}
private void testKeepAliveTimeout(HttpClientOptions options, int numReqs) throws Exception {
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(options.setPoolCleanerPeriod(1));
AtomicInteger respCount = new AtomicInteger();
for (int i = 0;i < numReqs;i++) {
int current = 1 + i;
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
respCount.incrementAndGet();
if (current == numReqs) {
long now = System.currentTimeMillis();
@@ -3958,7 +3943,7 @@ private void testKeepAliveTimeout(HttpClientOptions options, int numReqs) throws
testComplete();
});
}
- }));
+ })).end();
}
await();
}
@@ -3973,10 +3958,10 @@ public void testPoolNotExpiring() throws Exception {
req.connection().close();
});
});
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setPoolCleanerPeriod(0).setKeepAliveTimeout(100));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v1 -> {
resp.request().connection().closeHandler(v2 -> {
long time = System.currentTimeMillis() - now.get();
@@ -3984,7 +3969,7 @@ public void testPoolNotExpiring() throws Exception {
testComplete();
});
});
- }));
+ })).end();
await();
}
@@ -4008,11 +3993,11 @@ public void testPausedHttpServerRequestPauseTheConnectionAtRequestEnd() throws E
req.response().end();
});
});
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1));
for (int i = 0; i < numRequests; i++) {
- client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", resp -> {
+ client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", resp -> {
complete();
}).end("small");
}
@@ -4042,19 +4027,19 @@ public void testHttpClientResponsePauseIsIgnoredAtRequestEnd() throws Exception
private void testHttpClientResponsePause(Handler h) throws Exception {
server.requestHandler(req -> req.response().end("ok"));
- startServer();
+ startServer(testAddress);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setKeepAlive(true));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> {
+ client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1).setKeepAlive(true));
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> {
h.handle(resp1);
vertx.setTimer(10, timerId -> {
// The connection should be resumed as it's ended
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> {
assertSame(resp1.request().connection(), resp2.request().connection());
resp2.endHandler(v -> testComplete());
- }));
+ })).end();
});
- }));
+ })).end();
await();
}
@@ -4072,7 +4057,7 @@ public void testPoolLIFOPolicy() throws Exception {
break;
}
});
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(2));
// Make two concurrent requests and finish one first
@@ -4081,7 +4066,7 @@ public void testPoolLIFOPolicy() throws Exception {
// Use one event loop to be sure about response ordering
vertx.runOnContext(v0 -> {
for (int i = 0;i < 2;i++) {
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> {
resp.endHandler(v1 -> {
// Use runOnContext to be sure the connections is put back in the pool
vertx.runOnContext(v2 -> {
@@ -4089,14 +4074,14 @@ public void testPoolLIFOPolicy() throws Exception {
latch.countDown();
});
});
- }));
+ })).end();
}
});
awaitLatch(latch);
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> {
assertSame(resp.request().connection(), connections.get(1));
testComplete();
- }));
+ })).end();
await();
}
@@ -4151,13 +4136,13 @@ private void testHttpClientResponseThrowsExceptionInHandler(
resp.end();
}
});
- startServer();
+ startServer(testAddress);
int num = 50;
CountDownLatch latch = new CountDownLatch(num);
for (int i = 0;i < num;i++) {
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> {
handler.accept(resp, latch);
- }));
+ })).end();
}
awaitLatch(latch);
}
@@ -4170,8 +4155,8 @@ public void testConnectionCloseDuringShouldCallHandleExceptionOnlyOnce() throws
});
});
AtomicInteger count = new AtomicInteger();
- startServer();
- HttpClientRequest post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onFailure(res -> {}));
+ startServer(testAddress);
+ HttpClientRequest post = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onFailure(res -> {}));
post.setChunked(true);
post.write(TestUtils.randomBuffer(10000));
CountDownLatch latch = new CountDownLatch(1);
@@ -4199,9 +4184,9 @@ public void testDeferredRequestEnd() throws Exception {
req.resume();
});
});
- startServer();
+ startServer(testAddress);
Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(1024));
- client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
+ client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
resp.bodyHandler(body -> {
assertEquals(expected, body);
testComplete();
@@ -4231,12 +4216,12 @@ public void testPipelinedWithResponseSent() throws Exception {
req.resume();
});
});
- startServer();
+ startServer(testAddress);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true));
+ client = vertx.createHttpClient(createBaseClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true));
for (int i = 0;i < numReq;i++) {
String expected = "" + i;
- client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
+ client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
resp.bodyHandler(body -> {
assertEquals(expected, body.toString());
complete();
@@ -4260,12 +4245,12 @@ public void testPipelinedWithPendingResponse() throws Exception {
req.response().end("" + val);
});
});
- startServer();
+ startServer(testAddress);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true));
+ client = vertx.createHttpClient(createBaseClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true));
for (int i = 0;i < numReq;i++) {
String expected = "" + i;
- client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
+ client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
resp.bodyHandler(body -> {
assertEquals(expected, body.toString());
complete();
@@ -4301,12 +4286,12 @@ public void testPipelinedPostRequestStartedByResponseSent() throws Exception {
break;
}
});
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true));
- client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
+ client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
}).end(TestUtils.randomAlphaString(1024));
- HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
testComplete();
}).setChunked(true).write(chunk1);
awaitLatch(latch);
@@ -4327,14 +4312,14 @@ public void testBeginPipelinedRequestByResponseSentOnRequestCompletion() throws
req.response().end();
});
});
- startServer();
+ startServer(testAddress);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true));
+ client = vertx.createHttpClient(createBaseClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true));
client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
}).end(TestUtils.randomAlphaString(1024));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
testComplete();
- });
+ }).end();
await();
}
@@ -4353,14 +4338,14 @@ public void testBeginPipelinedRequestByResponseSentBeforeRequestCompletion() thr
req.response().end();
}
});
- startServer();
+ startServer(testAddress);
client.close();
- client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true));
- client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
+ client = vertx.createHttpClient(createBaseClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true));
+ client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
}).end(TestUtils.randomAlphaString(1024));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
testComplete();
- });
+ }).end();
await();
}
@@ -4370,15 +4355,15 @@ public void testHttpClientResponseBufferedWithPausedEnd() throws Exception {
server.requestHandler(req -> {
req.response().end("HelloWorld" + i.incrementAndGet());
});
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setKeepAlive(true));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> {
// Response is paused but request is put back in the pool since the HTTP response fully arrived
// but the response it's not yet delivered to the application as we pause the response
resp1.pause();
// Do a request on the same connection
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> {
resp2.bodyHandler(body2 -> {
// When the response arrives -> resume the first request
assertEquals("HelloWorld2", body2.toString());
@@ -4388,25 +4373,25 @@ public void testHttpClientResponseBufferedWithPausedEnd() throws Exception {
});
resp1.resume();
});
- }));
- }));
+ })).end();
+ })).end();
await();
}
@Test
public void testHttpClientResumeConnectionOnResponseOnLastMessage() throws Exception {
server.requestHandler(req -> req.response().end("ok"));
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setMaxPoolSize(1));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> {
resp1.pause();
// The connection resume is asynchronous and the end message will be received before connection resume happens
resp1.resume();
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> {
testComplete();
- }));
- }));
+ })).end();
+ })).end();
await();
}
@@ -4414,7 +4399,7 @@ public void testHttpClientResumeConnectionOnResponseOnLastMessage() throws Excep
public void testSetChunkedToFalse() throws Exception {
server.requestHandler(req -> req.response().setChunked(false).end());
startServer();
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
testComplete();
}).setChunked(false).end();
await();
@@ -4436,12 +4421,12 @@ public void testHttpServerRequestShouldCallExceptionHandlerWhenTheClosedHandlerI
}
});
});
- server.listen(onSuccess(s -> {
- client.getNow(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> {
vertx.setTimer(1000, id -> {
resp.request().connection().close();
});
- }));
+ })).end();
}));
await();
}
@@ -4453,8 +4438,8 @@ public void testHttpClientRequestShouldCallExceptionHandlerWhenTheClosedHandlerI
req.response().close();
});
});
- startServer();
- HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/someuri", resp -> {
+ startServer(testAddress);
+ HttpClientRequest req = client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/someuri", resp -> {
}).setChunked(true);
CheckingSender sender = new CheckingSender(vertx.getOrCreateContext(), req);
AtomicBoolean connected = new AtomicBoolean();
@@ -4513,14 +4498,14 @@ public void testChunkedServerResponse() {
vertx.setTimer(1, id -> {
resp.end();
});
- }).listen(onSuccess(server -> {
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
+ }).listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
assertEquals("chunked", res.getHeader("transfer-encoding"));
res.bodyHandler(body -> {
assertEquals("the-chunk", body.toString());
testComplete();
});
- }));
+ })).end();
}));
await();
}
@@ -4534,8 +4519,8 @@ public void testChunkedClientRequest() {
assertEquals("the-chunk", body.toString());
req.response().end();
});
- }).listen(onSuccess(server -> {
- HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", res -> {
+ }).listen(testAddress, onSuccess(server -> {
+ HttpClientRequest req = client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", res -> {
testComplete();
});
req.setChunked(true);
@@ -4580,8 +4565,8 @@ public void testHttpServerWithIdleTimeoutSendChunkedFile() throws Exception {
req -> {
req.response().sendFile(sent.getAbsolutePath());
});
- startServer();
- client.getNow(8080, "localhost", "/", onSuccess(resp -> {
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
long now = System.currentTimeMillis();
int[] length = {0};
resp.handler(buff -> {
@@ -4597,7 +4582,7 @@ public void testHttpServerWithIdleTimeoutSendChunkedFile() throws Exception {
assertTrue(System.currentTimeMillis() - now > 1000);
testComplete();
});
- }));
+ })).end();
await();
}
@@ -4610,16 +4595,16 @@ public void testSendFilePipelined() throws Exception {
req -> {
req.response().sendFile(sent.getAbsolutePath());
});
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(createBaseClientOptions().setPipelining(true).setMaxPoolSize(1));
for (int i = 0;i < n;i++) {
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.exceptionHandler(this::fail);
resp.bodyHandler(body -> {
complete();
});
- }));
+ })).end();
}
await();
}
diff --git a/src/test/java/io/vertx/core/http/Http2Test.java b/src/test/java/io/vertx/core/http/Http2Test.java
index 07a70126ce1..9da90210b40 100644
--- a/src/test/java/io/vertx/core/http/Http2Test.java
+++ b/src/test/java/io/vertx/core/http/Http2Test.java
@@ -11,6 +11,7 @@
package io.vertx.core.http;
+import io.netty.channel.socket.DuplexChannel;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http2.Http2CodecUtil;
import io.vertx.core.Context;
@@ -59,8 +60,8 @@ public void testServerResponseWriteBufferFromOtherThread() throws Exception {
runAsync(() -> {
req.response().write("hello ").end("world");
});
- }).listen(onSuccess(v -> {
- client.get(8080, "localhost", "/somepath", onSuccess(resp -> {
+ }).listen(testAddress, onSuccess(v -> {
+ client.request(HttpMethod.GET, testAddress, 8080, "localhost", "/somepath", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
resp.bodyHandler(buff -> {
assertEquals(Buffer.buffer("hello world"), buff);
@@ -78,8 +79,8 @@ public void testServerResponseResetFromOtherThread() throws Exception {
runAsync(() -> {
req.response().reset(0);
});
- }).listen(onSuccess(v -> {
- client.get(8080, "localhost", "/somepath", onFailure(err -> {
+ }).listen(testAddress, onSuccess(v -> {
+ client.request(HttpMethod.GET, testAddress, 8080, "localhost", "/somepath", onFailure(err -> {
assertTrue(err instanceof StreamResetException);
complete();
})).exceptionHandler(err -> {
@@ -109,11 +110,11 @@ public void testClientRequestWriteFromOtherThread() throws Exception {
req.endHandler(v -> {
req.response().end();
});
- }).listen(onSuccess(v -> {
+ }).listen(testAddress, onSuccess(v -> {
latch1.countDown();
}));
awaitLatch(latch1);
- HttpClientRequest req = client.get(8080, "localhost", "/somepath", onSuccess(resp -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, 8080, "localhost", "/somepath", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
testComplete();
})).setChunked(true).sendHead();
@@ -138,16 +139,8 @@ public void testServerOpenSSL() throws Exception {
server.requestHandler(req -> {
req.response().end();
});
- CountDownLatch latch = new CountDownLatch(1);
- System.out.println("starting");
- try {
- server.listen(onSuccess(v -> latch.countDown()));
- } catch (Throwable e) {
- e.printStackTrace();
- }
- System.out.println("listening");
- awaitLatch(latch);
- client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
assertEquals(200, resp.statusCode());
testComplete();
})).exceptionHandler(this::fail).end();
@@ -182,8 +175,8 @@ public void testServerStreamPausedWhenConnectionIsPaused() throws Exception {
}
}
});
- startServer();
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/0", onSuccess(resp -> {
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/0", onSuccess(resp -> {
resp.pause();
Context ctx = vertx.getOrCreateContext();
resumeLatch.thenAccept(v1 -> {
@@ -194,13 +187,13 @@ public void testServerStreamPausedWhenConnectionIsPaused() throws Exception {
resp.resume();
});
});
- }));
+ })).end();
awaitLatch(fullLatch);
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/1", onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/1", onSuccess(resp -> {
resp.endHandler(v -> {
complete();
});
- }));
+ })).end();
resumeLatch.get(20, TimeUnit.SECONDS); // Make sure it completes
await();
}
@@ -231,15 +224,15 @@ public void testClientStreamPausedWhenConnectionIsPaused() throws Exception {
}
}
});
- startServer();
- HttpClientRequest req1 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/0", resp -> {
+ startServer(testAddress);
+ HttpClientRequest req1 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/0", resp -> {
complete();
}).setChunked(true);
while (!req1.writeQueueFull()) {
req1.write(Buffer.buffer(TestUtils.randomAlphaString(512)));
Thread.sleep(1);
}
- HttpClientRequest req2 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/1", resp -> {
+ HttpClientRequest req2 = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/1", resp -> {
complete();
}).setChunked(true);
assertFalse(req2.writeQueueFull());
@@ -265,19 +258,19 @@ public void testResetClientRequestNotYetSent() throws Exception {
req.response().end();
complete();
});
- startServer();
+ startServer(testAddress);
// There might be a race between the request write and the request reset
// so we do it on the context thread to avoid it
vertx.runOnContext(v -> {
- HttpClientRequest post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
+ HttpClientRequest post = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
fail();
});
post.setChunked(true).write(TestUtils.randomBuffer(1024));
assertTrue(post.reset());
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
assertEquals(1, numReq.get());
complete();
- });
+ }).end();
});
await();
}
@@ -288,19 +281,19 @@ public void testDiscardConnectionWhenChannelBecomesInactive() throws Exception {
server.requestHandler(req -> {
if (count.getAndIncrement() == 0) {
Http2ServerConnection a = (Http2ServerConnection) req.connection();
- SocketChannel channel = (SocketChannel) a.channel();
+ DuplexChannel channel = (DuplexChannel) a.channel();
channel.shutdown();
} else {
req.response().end();
}
});
- startServer();
+ startServer(testAddress);
AtomicBoolean closed = new AtomicBoolean();
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {}))
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {}))
.connectionHandler(conn -> conn.closeHandler(v -> closed.set(true)))
.end();
AsyncTestBase.assertWaitUntil(closed::get);
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
testComplete();
}).exceptionHandler(err -> {
fail();
@@ -316,10 +309,10 @@ public void testClientDoesNotSupportAlpn() throws Exception {
req.response().end();
complete();
});
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(createBaseClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setUseAlpn(false));
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(HttpVersion.HTTP_1_1, resp.version());
complete();
})).exceptionHandler(this::fail).end();
@@ -336,8 +329,8 @@ public void testServerDoesNotSupportAlpn() throws Exception {
req.response().end();
complete();
});
- startServer();
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(HttpVersion.HTTP_1_1, resp.version());
complete();
})).exceptionHandler(this::fail).end();
@@ -349,7 +342,7 @@ public void testClientMakeRequestHttp2WithSSLWithoutAlpn() throws Exception {
client.close();
client = vertx.createHttpClient(createBaseClientOptions().setUseAlpn(false));
try {
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI);
fail();
} catch (IllegalArgumentException ignore) {
// Expected
@@ -372,9 +365,9 @@ public void testServePendingRequests() throws Exception {
}
}
});
- startServer();
+ startServer(testAddress);
for (int i = 0;i < n;i++) {
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> complete()).end();
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> complete()).end();
}
await();
}
@@ -391,8 +384,8 @@ public void testInitialMaxConcurrentStreamZero() throws Exception {
conn.updateSettings(new Http2Settings().setMaxConcurrentStreams(10));
});
});
- startServer();
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
testComplete();
}).connectionHandler(conn -> {
assertEquals(10, conn.remoteSettings().getMaxConcurrentStreams());
@@ -410,14 +403,14 @@ public void testFoo() throws Exception {
assertNull(resp.headers().get("content-length"));
complete();
});
- startServer();
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertNull(resp.getHeader("content-length"));
resp.bodyHandler(body -> {
assertEquals("HelloWorld", body.toString());
complete();
});
- }));
+ })).end();
await();
}
@@ -426,10 +419,10 @@ public void testKeepAliveTimeout() throws Exception {
server.requestHandler(req -> {
req.response().end();
});
- startServer();
+ startServer(testAddress);
client.close();
client = vertx.createHttpClient(createBaseClientOptions().setHttp2KeepAliveTimeout(3).setPoolCleanerPeriod(1));
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
long now = System.currentTimeMillis();
resp.request().connection().closeHandler(v -> {
long timeout = System.currentTimeMillis() - now;
@@ -440,7 +433,7 @@ public void testKeepAliveTimeout() throws Exception {
assertTrue("Expected actual close timeout " + timeout + " to be < " + high, timeout < high);
testComplete();
});
- }));
+ })).end();
await();
}
@@ -461,9 +454,9 @@ public void testStreamWeightAndDependency() throws Exception {
req.response().end();
complete();
});
- startServer();
+ startServer(testAddress);
client = vertx.createHttpClient(createBaseClientOptions().setHttp2KeepAliveTimeout(3).setPoolCleanerPeriod(1));
- HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest request = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(responseStreamWeight, resp.request().getStreamPriority().getWeight());
assertEquals(responseStreamDependency, resp.request().getStreamPriority().getDependency());
complete();
@@ -510,9 +503,9 @@ public void testStreamWeightAndDependencyChange() throws Exception {
req.response().end("world");
complete();
});
- startServer();
+ startServer(testAddress);
client = vertx.createHttpClient(createBaseClientOptions().setHttp2KeepAliveTimeout(3).setPoolCleanerPeriod(1));
- HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest request = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(responseStreamWeight, resp.request().getStreamPriority().getWeight());
assertEquals(responseStreamDependency, resp.request().getStreamPriority().getDependency());
resp.streamPriorityHandler( sp -> {
@@ -564,9 +557,9 @@ public void testStreamWeightAndDependencyNoChange() throws Exception {
req.response().end("world");
complete();
});
- startServer();
+ startServer(testAddress);
client = vertx.createHttpClient(createBaseClientOptions().setHttp2KeepAliveTimeout(3).setPoolCleanerPeriod(1));
- HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest request = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(responseStreamWeight, resp.request().getStreamPriority().getWeight());
assertEquals(responseStreamDependency, resp.request().getStreamPriority().getDependency());
resp.streamPriorityHandler( sp -> {
@@ -601,9 +594,9 @@ public void testStreamWeightAndDependencyInheritance() throws Exception {
req.response().end();
complete();
});
- startServer();
+ startServer(testAddress);
client = vertx.createHttpClient(createBaseClientOptions().setHttp2KeepAliveTimeout(3).setPoolCleanerPeriod(1));
- HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest request = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(requestStreamWeight, resp.request().getStreamPriority().getWeight());
assertEquals(requestStreamDependency, resp.request().getStreamPriority().getDependency());
complete();
@@ -627,9 +620,9 @@ public void testDefaultStreamWeightAndDependency() throws Exception {
req.response().end();
complete();
});
- startServer();
+ startServer(testAddress);
client = vertx.createHttpClient(createBaseClientOptions().setHttp2KeepAliveTimeout(3).setPoolCleanerPeriod(1));
- HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest request = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(defaultStreamWeight, resp.request().getStreamPriority().getWeight());
assertEquals(defaultStreamDependency, resp.request().getStreamPriority().getDependency());
complete();
@@ -656,9 +649,9 @@ public void testStreamWeightAndDependencyPushPromise() throws Exception {
req.response().end();
complete();
});
- startServer();
+ startServer(testAddress);
client = vertx.createHttpClient(createBaseClientOptions().setHttp2KeepAliveTimeout(3).setPoolCleanerPeriod(1));
- HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
+ HttpClientRequest request = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
complete();
});
request.pushHandler(pushReq -> {
@@ -687,9 +680,9 @@ public void testStreamWeightAndDependencyInheritancePushPromise() throws Excepti
req.response().end();
complete();
});
- startServer();
+ startServer(testAddress);
client = vertx.createHttpClient(createBaseClientOptions().setHttp2KeepAliveTimeout(3).setPoolCleanerPeriod(1));
- HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ HttpClientRequest request = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
complete();
}));
request.pushHandler(pushReq -> {
diff --git a/src/test/java/io/vertx/core/http/HttpTest.java b/src/test/java/io/vertx/core/http/HttpTest.java
index 83436883b10..f4c5aeee99c 100644
--- a/src/test/java/io/vertx/core/http/HttpTest.java
+++ b/src/test/java/io/vertx/core/http/HttpTest.java
@@ -56,11 +56,17 @@ public abstract class HttpTest extends HttpTestBase {
public TemporaryFolder testFolder = new TemporaryFolder();
protected File testDir;
+ private File tmp;
@Override
public void setUp() throws Exception {
super.setUp();
testDir = testFolder.newFolder();
+ if (USE_DOMAIN_SOCKETS) {
+ assertTrue("Native transport not enabled", USE_NATIVE_TRANSPORT);
+ tmp = TestUtils.tmpFile(".sock");
+ testAddress = SocketAddress.domainSocketAddress(tmp.getAbsolutePath());
+ }
}
@Test
@@ -84,8 +90,8 @@ public void testClientRequestArguments() throws Exception {
public void testClientChaining() {
server.requestHandler(noOpHandler());
- server.listen(onSuccess(server -> {
- HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
+ server.listen(testAddress, onSuccess(server -> {
+ HttpClientRequest req = client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
assertTrue(req.setChunked(true) == req);
assertTrue(req.sendHead() == req);
assertTrue(req.write("foo", "UTF-8") == req);
@@ -123,18 +129,16 @@ public void testListenSocketAddress() {
public void testListenDomainSocketAddress() throws Exception {
Vertx vx = Vertx.vertx(new VertxOptions().setPreferNativeTransport(true));
Assume.assumeTrue("Native transport must be enabled", vx.isNativeTransportEnabled());
- NetClient netClient = vx.createNetClient();
- HttpServer httpserver = vx.createHttpServer().requestHandler(req -> req.response().end());
+ HttpServer httpserver = vx.createHttpServer(createBaseServerOptions()).requestHandler(req -> req.response().end());
File sockFile = TestUtils.tmpFile(".sock");
SocketAddress sockAddress = SocketAddress.domainSocketAddress(sockFile.getAbsolutePath());
httpserver.listen(sockAddress, onSuccess(server -> {
- netClient.connect(sockAddress, onSuccess(sock -> {
- sock.handler(buf -> {
- assertTrue("Response is not an http 200", buf.toString("UTF-8").startsWith("HTTP/1.1 200 OK"));
- testComplete();
- });
- sock.write("GET / HTTP/1.1\r\n\r\n");
- }));
+ client.request(HttpMethod.GET, sockAddress, new RequestOptions()
+ .setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT).setURI(DEFAULT_TEST_URI), onSuccess(resp -> {
+ resp.endHandler(v -> {
+ testComplete();
+ });
+ })).end();
}));
try {
@@ -146,7 +150,7 @@ public void testListenDomainSocketAddress() throws Exception {
@Test
- public void testLowerCaseHeaders() {
+ public void testLowerCaseHeaders() throws Exception {
server.requestHandler(req -> {
assertEquals("foo", req.headers().get("Foo"));
assertEquals("foo", req.headers().get("foo"));
@@ -167,8 +171,8 @@ public void testLowerCaseHeaders() {
req.response().end();
});
- server.listen(onSuccess(server -> {
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(server -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals("quux", resp.headers().get("Quux"));
assertEquals("quux", resp.headers().get("quux"));
assertEquals("quux", resp.headers().get("qUUX"));
@@ -285,8 +289,8 @@ public void testPutHeadersOnRequest() {
assertEquals("bar", req.getHeader("foo"));
req.response().end();
});
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(200, resp.statusCode());
testComplete();
})).putHeader("foo", "bar").end();
@@ -301,8 +305,8 @@ public void testPutHeaderReplacesPreviousHeaders() throws Exception {
.putHeader("Location", "http://example1.org")
.putHeader("location", "http://example2.org")
.end());
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(singletonList("http://example2.org"), resp.headers().getAll("LocatioN"));
testComplete();
})).end();
@@ -438,9 +442,9 @@ private void testSimpleRequest(String uri, HttpMethod method, boolean absolute,
boolean ssl = this instanceof Http2Test;
HttpClientRequest req;
if (absolute) {
- req = client.requestAbs(method, (ssl ? "https://" : "http://") + DEFAULT_HTTP_HOST + ":" + DEFAULT_HTTP_PORT + uri, onSuccess(handler::handle));
+ req = client.requestAbs(method, testAddress, (ssl ? "https://" : "http://") + DEFAULT_HTTP_HOST + ":" + DEFAULT_HTTP_PORT + uri, onSuccess(handler::handle));
} else {
- req = client.request(method, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, uri, onSuccess(handler::handle));
+ req = client.request(method, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, uri, onSuccess(handler::handle));
}
testSimpleRequest(uri, method, req, absolute);
}
@@ -466,7 +470,7 @@ private void testSimpleRequest(String uri, HttpMethod method, HttpClientRequest
req.response().end();
});
- server.listen(onSuccess(server -> request.end()));
+ server.listen(testAddress, onSuccess(server -> request.end()));
await();
}
@@ -480,8 +484,8 @@ public void testServerChaining() {
testComplete();
});
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()).end();
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()).end();
}));
await();
@@ -497,8 +501,8 @@ public void testServerChainingSendFile() throws Exception {
testComplete();
});
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()).end();
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()).end();
}));
await();
@@ -520,8 +524,8 @@ public void testResponseEndHandlers1() {
complete();
});
req.response().end();
- }).listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
+ }).listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
assertEquals(200, res.statusCode());
assertEquals("wibble", res.headers().get("extraheader"));
complete();
@@ -547,8 +551,8 @@ public void testResponseEndHandlers2() {
complete();
});
req.response().end(content);
- }).listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
+ }).listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
assertEquals(200, res.statusCode());
assertEquals("wibble", res.headers().get("extraheader"));
res.bodyHandler(buff -> {
@@ -584,8 +588,8 @@ public void testResponseEndHandlersChunkedResponse() {
IntStream.range(0, numChunks - 1).forEach(x -> req.response().write(chunk));
// End with a chunk to ensure size is correctly calculated
req.response().end(chunk);
- }).listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
+ }).listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
assertEquals(200, res.statusCode());
assertEquals("wibble", res.headers().get("extraheader"));
res.bodyHandler(buff -> {
@@ -615,8 +619,8 @@ public void testResponseEndHandlersSendFile() throws Exception {
complete();
});
req.response().sendFile(toSend.getAbsolutePath());
- }).listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
+ }).listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
assertEquals(200, res.statusCode());
assertEquals("wibble", res.headers().get("extraheader"));
res.bodyHandler(buff -> {
@@ -660,8 +664,8 @@ private void testURIAndPath(String uri, String path) {
req.response().end();
});
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, uri, resp -> testComplete()).end();
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, uri, resp -> testComplete()).end();
}));
await();
@@ -708,8 +712,8 @@ private void testParamDecoding(String value) throws UnsupportedEncodingException
req.response().end();
});
String postData = "param=" + URLEncoder.encode(value,"UTF-8");
- server.listen(onSuccess(server -> {
- client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> testComplete()))
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> testComplete()))
.putHeader(HttpHeaders.CONTENT_TYPE, HttpHeaders.APPLICATION_X_WWW_FORM_URLENCODED)
.putHeader(HttpHeaders.CONTENT_LENGTH, String.valueOf(postData.length()))
.write(postData).end();
@@ -731,7 +735,6 @@ public void testParamsSemiColon() {
private void testParams(char delim) {
Map params = genMap(10);
String query = generateQueryString(params, delim);
-
server.requestHandler(req -> {
assertEquals(query, req.query());
assertEquals(params.size(), req.params().size());
@@ -741,8 +744,8 @@ private void testParams(char delim) {
req.response().end();
});
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "some-uri/?" + query, resp -> testComplete()).end();
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "some-uri/?" + query, resp -> testComplete()).end();
}));
await();
@@ -779,8 +782,8 @@ public void testDefaultRequestHeaders() {
req.response().end();
});
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end();
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end();
}));
await();
@@ -803,8 +806,8 @@ public void testRequestHeadersWithCharSequence() {
req.response().end();
});
- server.listen(onSuccess(server -> {
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete());
+ server.listen(testAddress, onSuccess(server -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete());
headers.forEach((k, v) -> req.headers().add(k, v));
@@ -836,8 +839,8 @@ private void testRequestHeaders(boolean individually) {
req.response().end();
});
- server.listen(onSuccess(server -> {
- HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete());
+ server.listen(testAddress, onSuccess(server -> {
+ HttpClientRequest req = client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete());
if (individually) {
for (Map.Entry header : headers) {
req.headers().add(header.getKey(), header.getValue());
@@ -875,8 +878,8 @@ private void testResponseHeaders(boolean individually) {
req.response().end();
});
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertTrue(headers.size() < resp.headers().size());
for (Map.Entry entry : headers) {
assertEquals(entry.getValue(), resp.headers().get(entry.getKey()));
@@ -901,8 +904,8 @@ public void testResponseHeadersWithCharSequence() {
req.response().end();
});
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertTrue(headers.size() < resp.headers().size());
headers.forEach((k,v) -> assertEquals(v, resp.headers().get(k)));
@@ -952,8 +955,8 @@ private void testResponseMultipleSetCookie(boolean inHeader, boolean inTrailer)
req.response().end();
});
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
assertEquals(cookies.size(), resp.cookies().size());
for (int i = 0; i < cookies.size(); ++i) {
@@ -971,8 +974,8 @@ private void testResponseMultipleSetCookie(boolean inHeader, boolean inTrailer)
public void testUseRequestAfterComplete() {
server.requestHandler(noOpHandler());
- server.listen(onSuccess(server -> {
- HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
+ server.listen(testAddress, onSuccess(server -> {
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
req.end();
Buffer buff = Buffer.buffer();
@@ -1005,8 +1008,8 @@ public void testRequestBodyBufferAtEnd() {
req.response().end();
}));
- server.listen(onSuccess(server -> {
- client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end(body);
+ server.listen(testAddress, onSuccess(server -> {
+ client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end(body);
}));
await();
@@ -1044,8 +1047,8 @@ private void testRequestBodyStringAtEnd(String encoding) {
});
});
- server.listen(onSuccess(server -> {
- HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
+ server.listen(testAddress, onSuccess(server -> {
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
if (encoding == null) {
req.end(body);
} else {
@@ -1076,8 +1079,8 @@ private void testRequestBodyWrite(boolean chunked) {
});
});
- server.listen(onSuccess(server -> {
- HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete());
+ server.listen(testAddress, onSuccess(server -> {
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete());
int numWrites = 10;
int chunkSize = 100;
@@ -1144,8 +1147,8 @@ private void testRequestBodyWriteString(boolean chunked, String encoding) {
});
});
- server.listen(onSuccess(server -> {
- HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
+ server.listen(testAddress, onSuccess(server -> {
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
if (chunked) {
req.setChunked(true);
@@ -1178,8 +1181,8 @@ public void testRequestWrite() {
testComplete();
});
});
- server.listen(onSuccess(s -> {
- HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
+ server.listen(testAddress, onSuccess(s -> {
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
req.setChunked(true);
int padding = 5;
for (int i = 0;i < times;i++) {
@@ -1238,8 +1241,8 @@ public void testConnectWithoutResponseHandler() throws Exception {
}
@Test
- public void testClientExceptionHandlerCalledWhenFailingToConnect() throws Exception {
- client.request(HttpMethod.GET, 9998, "255.255.255.255", DEFAULT_TEST_URI, onFailure(err ->
+ public void testClientExceptionHandlerCalledWhenFailingToConnect() {
+ client.request(HttpMethod.GET, testAddress, 9998, "255.255.255.255", DEFAULT_TEST_URI, onFailure(err ->
testComplete()))
.exceptionHandler(error -> fail("Exception handler should not be called"))
.end();
@@ -1249,20 +1252,20 @@ public void testClientExceptionHandlerCalledWhenFailingToConnect() throws Except
@Test
public void testClientExceptionHandlerCalledWhenServerTerminatesConnection() throws Exception {
int numReqs = 10;
- CountDownLatch latch = new CountDownLatch(numReqs);
+ waitFor(numReqs);
server.requestHandler(request -> {
request.response().close();
- }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
+ }).listen(testAddress, onSuccess(s -> {
// Exception handler should be called for any requests in the pipeline if connection is closed
for (int i = 0; i < numReqs; i++) {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {
- latch.countDown();
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {
+ complete();
}))
.exceptionHandler(error -> fail("Exception handler should not be called"))
.end();
}
}));
- awaitLatch(latch);
+ await();
}
@Test
@@ -1270,9 +1273,9 @@ public void testClientExceptionHandlerCalledWhenServerTerminatesConnectionAfterP
server.requestHandler(request -> {
//Write partial response then close connection before completing it
request.response().setChunked(true).write("foo").close();
- }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
+ }).listen(testAddress, onSuccess(s -> {
// Exception handler should be called for any requests in the pipeline if connection is closed
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp ->
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp ->
resp.exceptionHandler(t -> testComplete()))).exceptionHandler(error -> fail()).end();
}));
await();
@@ -1282,9 +1285,9 @@ public void testClientExceptionHandlerCalledWhenServerTerminatesConnectionAfterP
public void testContextExceptionHandlerCalledWhenExceptionOnDataHandler() throws Exception {
server.requestHandler(request -> {
request.response().end("foo");
- }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
+ }).listen(testAddress, onSuccess(s -> {
// Exception handler should be called for any exceptions in the data handler
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
RuntimeException cause = new RuntimeException("should be caught");
resp.exceptionHandler(err -> {
if (err == cause) {
@@ -1303,9 +1306,9 @@ public void testContextExceptionHandlerCalledWhenExceptionOnDataHandler() throws
public void testClientExceptionHandlerCalledWhenExceptionOnBodyHandler() throws Exception {
server.requestHandler(request -> {
request.response().end("foo");
- }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
+ }).listen(testAddress, onSuccess(s -> {
// Exception handler should be called for any exceptions in the data handler
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
RuntimeException cause = new RuntimeException("should be caught");
resp.exceptionHandler(err -> {
if (err == cause) {
@@ -1326,11 +1329,11 @@ public void testNoExceptionHandlerCalledWhenResponseEnded() throws Exception {
HttpServerResponse resp = req.response();
req.exceptionHandler(this::fail);
resp.exceptionHandler(err -> {
- err.printStackTrace();
+ fail(err);
});
resp.end();
- }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
- client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ }).listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
vertx.setTimer(100, tid -> testComplete());
});
@@ -1379,9 +1382,9 @@ public void testServerExceptionHandlerOnClose() {
assertEquals(1, respEndHandlerCount.get());
testComplete();
});
- }).listen(DEFAULT_HTTP_PORT, ar -> {
+ }).listen(testAddress, ar -> {
HttpClient client = vertx.createHttpClient();
- HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somerui", handler -> {
+ HttpClientRequest req = client.request(HttpMethod.PUT, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somerui", handler -> {
}).setChunked(true);
req.sendHead(v -> {
@@ -1398,8 +1401,8 @@ public void testClientRequestExceptionHandlerCalledWhenConnectionClosed() throws
req.connection().close();
});
});
- startServer();
- HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {})).setChunked(true);
+ startServer(testAddress);
+ HttpClientRequest req = client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {})).setChunked(true);
req.exceptionHandler(err -> {
testComplete();
});
@@ -1414,15 +1417,15 @@ public void testClientResponseExceptionHandlerCalledWhenConnectionClosed() throw
conn.set(req.connection());
req.response().setChunked(true).write("chunk");
});
- startServer();
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
resp.handler(buff -> {
conn.get().close();
});
resp.exceptionHandler(err -> {
testComplete();
});
- }));
+ })).end();
await();
}
@@ -1458,8 +1461,8 @@ private void testStatusCode(int code, String statusMessage) {
req.response().end();
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
int theCode;
if (code == -1) {
// Default code - 200
@@ -1505,8 +1508,8 @@ private void testResponseTrailers(boolean individually) {
req.response().end();
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
assertEquals(trailers.size(), resp.trailers().size());
for (Map.Entry entry : trailers) {
@@ -1528,8 +1531,8 @@ public void testResponseNoTrailers() {
req.response().end();
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.endHandler(v -> {
assertTrue(resp.trailers().isEmpty());
testComplete();
@@ -1550,8 +1553,8 @@ public void testUseResponseAfterComplete() throws Exception {
checkHttpServerResponse(resp);
testComplete();
});
- startServer();
- client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler());
+ startServer(testAddress);
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()).end();
await();
}
@@ -1581,8 +1584,8 @@ public void testResponseBodyBufferAtEnd() {
req.response().end(body);
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.bodyHandler(buff -> {
assertEquals(body, buff);
testComplete();
@@ -1627,8 +1630,8 @@ private void testResponseBodyWrite(boolean chunked) {
assertTrue(req.response().headWritten());
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.bodyHandler(buff -> {
assertEquals(body, buff);
testComplete();
@@ -1693,8 +1696,8 @@ private void testResponseBodyWriteString(boolean chunked, String encoding) {
req.response().end();
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.bodyHandler(buff -> {
assertEquals(bodyBuff, buff);
testComplete();
@@ -1715,8 +1718,8 @@ public void testResponseWrite() {
req.response().end();
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.POST, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.bodyHandler(buff -> {
assertEquals(body, buff);
testComplete();
@@ -1731,14 +1734,14 @@ public void testResponseWrite() {
public void testSendFile() throws Exception {
String content = TestUtils.randomUnicodeString(10000);
sendFile("test-send-file.html", content, false,
- handler -> client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, handler));
+ handler -> client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, handler));
}
@Test
public void testSendFileWithHandler() throws Exception {
String content = TestUtils.randomUnicodeString(10000);
sendFile("test-send-file.html", content, true,
- handler -> client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, handler));
+ handler -> client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, handler));
}
@Test
@@ -1746,7 +1749,7 @@ public void testSendFileWithConnectionCloseHeader() throws Exception {
String content = TestUtils.randomUnicodeString(1024 * 1024 * 2);
sendFile("test-send-file.html", content, false,
handler -> client
- .get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, handler)
+ .request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, handler)
.putHeader(HttpHeaders.CONNECTION, "close"));
}
@@ -1762,7 +1765,7 @@ private void sendFile(String fileName, String contentExpected, boolean useHandle
complete();
}
});
- startServer();
+ startServer(testAddress);
requestFact.apply(onSuccess(resp -> {
assertEquals(200, resp.statusCode());
assertEquals("text/html", resp.headers().get("Content-Type"));
@@ -1788,8 +1791,8 @@ public void testSendNonExistingFile() throws Exception {
});
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.bodyHandler(buff -> {
assertEquals("failed", buff.toString());
testComplete();
@@ -1810,8 +1813,8 @@ public void testSendFileOverrideHeaders() throws Exception {
req.response().sendFile(file.getAbsolutePath());
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
assertEquals(file.length(), Long.parseLong(resp.headers().get("content-length")));
assertEquals("wibble", resp.headers().get("content-type"));
resp.bodyHandler(buff -> {
@@ -1833,8 +1836,8 @@ public void testSendFileNotFound() throws Exception {
req.response().sendFile("nosuchfile.html");
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {})).end();
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {})).end();
vertx.setTimer(100, tid -> testComplete());
}));
@@ -1852,8 +1855,8 @@ public void testSendFileNotFoundWithHandler() throws Exception {
}));
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(resp -> {})).end();
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(resp -> {})).end();
}));
await();
@@ -1872,8 +1875,8 @@ public void testSendFileDirectoryWithHandler() throws Exception {
}));
});
- server.listen(onSuccess(s -> {
- client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {})).end();
+ server.listen(testAddress, onSuccess(s -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {})).end();
}));
await();
@@ -1881,10 +1884,10 @@ public void testSendFileDirectoryWithHandler() throws Exception {
@Test
public void testSendOpenRangeFileFromClasspath() {
- vertx.createHttpServer(new HttpServerOptions().setPort(8080)).requestHandler(res -> {
+ server.requestHandler(res -> {
res.response().sendFile("webroot/somefile.html", 6);
- }).listen(onSuccess(res -> {
- vertx.createHttpClient(new HttpClientOptions()).request(HttpMethod.GET, 8080, "localhost", "/", onSuccess(resp -> {
+ }).listen(testAddress, onSuccess(res -> {
+ client.request(HttpMethod.GET, testAddress, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
resp.bodyHandler(buff -> {
assertTrue(buff.toString().startsWith("blah