Java Code Examples for reactor.netty.resources.ConnectionProvider#create()

@Test
public void contentHeader() {
	ConnectionProvider fixed = ConnectionProvider.create("contentHeader", 1);
	HttpClient client =
			HttpClient.create(fixed)
			          .wiretap(true)
			          .headers(h -> h.add("content-length", "1"));

	HttpResponseStatus r =
			client.request(HttpMethod.GET)
			      .uri(getURL())
			      .send(ByteBufFlux.fromString(Mono.just(" ")))
			      .responseSingle((res, buf) -> Mono.just(res.status()))
			      .block(Duration.ofSeconds(30));

	client.request(HttpMethod.GET)
	      .uri(getURL())
	      .send(ByteBufFlux.fromString(Mono.just(" ")))
	      .responseSingle((res, buf) -> Mono.just(res.status()))
	      .block(Duration.ofSeconds(30));

	Assert.assertEquals(r, HttpResponseStatus.BAD_REQUEST);
	fixed.dispose();
}
 

@Test
public void testExplicitSendMonoErrorOnGet() {
	disposableServer =
			HttpServer.create()
			          .port(0)
			          .handle((req, res) -> res.send(req.receive().retain()))
			          .bindNow();

	ConnectionProvider pool = ConnectionProvider.create("test", 1);

	StepVerifier.create(
			Flux.range(0, 1000)
			    .flatMapDelayError(i ->
			        createHttpClientForContextWithAddress(pool)
			                .request(HttpMethod.GET)
			                .uri("/")
			                .send((req, out) -> out.send(Mono.error(new Exception("test"))))
			                .responseContent(), Queues.SMALL_BUFFER_SIZE, Queues.XS_BUFFER_SIZE))
			    .expectError()
			    .verify(Duration.ofSeconds(30));

	pool.dispose();
}
 

@Test
//https://github.com/reactor/reactor-pool/issues/82
public void testConnectionRefusedConcurrentRequests(){
	ConnectionProvider provider = ConnectionProvider.create("testConnectionRefusedConcurrentRequests", 1);

	HttpClient httpClient = HttpClient.create(provider)
	                                  .port(8282);

	Mono<String> mono1 =
			httpClient.get()
			          .responseSingle((r, buf) -> buf.asString())
			          .log("mono1");

	Mono<String> mono2 =
			httpClient.get()
			          .responseSingle((r, buf) -> buf.asString())
			          .log("mono2");

	StepVerifier.create(Flux.just(mono1.onErrorResume(e -> Mono.empty()), mono2)
	                        .flatMap(Function.identity()))
	            .expectError()
	            .verify(Duration.ofSeconds(5));

	provider.disposeLater()
	        .block(Duration.ofSeconds(5));
}
 

@Test
public void testConcurrentStreamsH2() throws Exception {
	doTestConcurrentStreams(HttpClient.create(), true, HttpProtocol.H2);

	ConnectionProvider provider = ConnectionProvider.create("testConcurrentStreams", 1);
	doTestConcurrentStreams(HttpClient.create(provider), true, HttpProtocol.H2);
	provider.disposeLater()
	        .block();

	doTestConcurrentStreams(HttpClient.newConnection(), true, HttpProtocol.H2);
}
 

@Test
public void testConcurrentStreamsH2C() throws Exception {
	doTestConcurrentStreams(HttpClient.create(), false, HttpProtocol.H2C);

	ConnectionProvider provider = ConnectionProvider.create("testConcurrentStreams", 1);
	doTestConcurrentStreams(HttpClient.create(provider), false, HttpProtocol.H2C);
	provider.disposeLater()
	        .block();

	doTestConcurrentStreams(HttpClient.newConnection(), false, HttpProtocol.H2C);
}
 

@Test
public void testConnectionNoLifeTimeElasticPool() throws Exception {
	ConnectionProvider provider =
			ConnectionProvider.create("testConnectionNoLifeTimeElasticPool", Integer.MAX_VALUE);
	ChannelId[] ids = doTestConnectionLifeTime(provider);
	assertThat(ids[0]).isEqualTo(ids[1]);
}
 

@Test
public void testConnectionNoIdleTimeElasticPool() throws Exception {
	ConnectionProvider provider =
			ConnectionProvider.create("testConnectionNoIdleTimeElasticPool", Integer.MAX_VALUE);
	ChannelId[] ids = doTestConnectionIdleTime(provider);
	assertThat(ids[0]).isEqualTo(ids[1]);
}
 

@Test
public void testConcurrentStreamsH2CUpgrade() throws Exception {
	doTestConcurrentStreams(HttpClient.create(), false, HttpProtocol.H2C, HttpProtocol.HTTP11);

	ConnectionProvider provider = ConnectionProvider.create("testConcurrentStreamsH2CUpgrade", 1);
	doTestConcurrentStreams(HttpClient.create(provider), false, HttpProtocol.H2C, HttpProtocol.HTTP11);
	provider.disposeLater()
	        .block();

	doTestConcurrentStreams(HttpClient.newConnection(), false, HttpProtocol.H2C, HttpProtocol.HTTP11);
}
 

@Test
public void disableChunkImplicitDefault() {
	ConnectionProvider p = ConnectionProvider.create("disableChunkImplicitDefault", 1);
	HttpClient client =
			HttpClient.create(p)
			          .host("localhost")
			          .port(getPort())
			          .wiretap(true);

	Tuple2<HttpResponseStatus, Channel> r =
			client.get()
			      .uri("/status/404")
			      .responseConnection((res, conn) -> Mono.just(res.status())
			                                             .delayUntil(s -> conn.inbound().receive())
			                                             .zipWith(Mono.just(conn.channel())))
			      .blockLast(Duration.ofSeconds(30));

	assertThat(r).isNotNull();

	Channel r2 =
			client.get()
			      .uri("/status/404")
			      .responseConnection((res, conn) -> Mono.just(conn.channel())
			                                             .delayUntil(s -> conn.inbound().receive()))
			      .blockLast(Duration.ofSeconds(30));

	assertThat(r2).isNotNull();

	Assert.assertSame(r.getT2(), r2);

	Assert.assertEquals(r.getT1(), HttpResponseStatus.NOT_FOUND);
	p.dispose();
}
 

@Test
public void simpleTest404_1() {
	ConnectionProvider pool = ConnectionProvider.create("simpleTest404_1", 1);
	HttpClient client =
			HttpClient.create(pool)
			          .port(getPort())
			          .host("localhost")
			          .wiretap(true);
	doSimpleTest404(client);
	doSimpleTest404(client);
	pool.dispose();
}
 

@Test
public void testConcurrentStreamsNegotiatedProtocolHTTP11() throws Exception {
	doTestConcurrentStreams(HttpClient.create(), true, new HttpProtocol[]{HttpProtocol.HTTP11},
			new HttpProtocol[]{HttpProtocol.H2, HttpProtocol.HTTP11});

	ConnectionProvider provider = ConnectionProvider.create("testConcurrentStreamsH2CUpgrade", 1);
	doTestConcurrentStreams(HttpClient.create(provider), true, new HttpProtocol[]{HttpProtocol.HTTP11},
			new HttpProtocol[]{HttpProtocol.H2, HttpProtocol.HTTP11});
	provider.disposeLater()
	        .block();

	doTestConcurrentStreams(HttpClient.newConnection(), true, new HttpProtocol[]{HttpProtocol.HTTP11},
			new HttpProtocol[]{HttpProtocol.H2, HttpProtocol.HTTP11});
}
 

@Test
public void testCustomConnectionProvider() {
	disposableServer =
			HttpServer.create()
			          .protocol(HttpProtocol.H2C)
			          .route(routes ->
			              routes.post("/echo", (req, res) -> res.send(req.receive().retain())))
			          .port(0)
			          .wiretap(true)
			          .bindNow();

	ConnectionProvider provider = ConnectionProvider.create("testCustomConnectionProvider", 1);
	String response =
			HttpClient.create(provider, 1)
			          .port(disposableServer.port())
			          .protocol(HttpProtocol.H2C)
			          .wiretap(true)
			          .post()
			          .uri("/echo")
			          .send(ByteBufFlux.fromString(Mono.just("testCustomConnectionProvider")))
			          .responseContent()
			          .aggregate()
			          .asString()
			          .block(Duration.ofSeconds(30));

	assertThat(response).isEqualTo("testCustomConnectionProvider");

	provider.disposeLater()
	        .block(Duration.ofSeconds(30));
}
 

@Test
public void testClientReuseIssue405(){
	disposableServer =
			HttpServer.create()
			          .port(0)
			          .handle((in,out)->out.sendString(Flux.just("hello")))
			          .wiretap(true)
			          .bindNow();

	ConnectionProvider pool = ConnectionProvider.create("testClientReuseIssue405", 1);
	HttpClient httpClient = createHttpClientForContextWithPort(pool);

	Mono<String> mono1 =
			httpClient.get()
			          .responseSingle((r, buf) -> buf.asString())
			          .log("mono1");

	Mono<String> mono2 =
			httpClient.get()
			          .responseSingle((r, buf) -> buf.asString())
			          .log("mono1");

	StepVerifier.create(Flux.zip(mono1,mono2))
	            .expectNext(Tuples.of("hello","hello"))
	            .expectComplete()
	            .verify(Duration.ofSeconds(20));

	pool.dispose();
}
 

@Test
public void userIssue() throws Exception {
	final ConnectionProvider pool = ConnectionProvider.create("userIssue", 1);
	CountDownLatch latch = new CountDownLatch(3);
	Set<String> localAddresses = ConcurrentHashMap.newKeySet();
	disposableServer =
			HttpServer.create()
			          .port(8080)
			          .route(r -> r.post("/",
			                  (req, resp) -> req.receive()
			                                    .asString()
			                                    .flatMap(data -> {
			                                        latch.countDown();
			                                        return resp.status(200)
			                                                   .send();
			                                    })))
			          .wiretap(true)
			          .bindNow();

	final HttpClient client = createHttpClientForContextWithAddress(pool);

	Flux.just("1", "2", "3")
	    .concatMap(data ->
	            client.doOnResponse((res, conn) ->
	                    localAddresses.add(conn.channel()
	                                           .localAddress()
	                                           .toString()))
	                  .post()
	                  .uri("/")
	                  .send(ByteBufFlux.fromString(Flux.just(data)))
	                  .responseContent())
	    .subscribe();


	latch.await();
	pool.dispose();
	System.out.println("Local Addresses used: " + localAddresses);
}
 

@Test
public void testMaxActiveStreams_2() throws Exception {
	doTestMaxActiveStreams(HttpClient.create(), 2, 2, 0);

	ConnectionProvider provider = ConnectionProvider.create("testMaxActiveStreams_2", 1);
	doTestMaxActiveStreams(HttpClient.create(provider), 2, 2, 0);
	provider.disposeLater()
	        .block();

	doTestMaxActiveStreams(HttpClient.newConnection(), 2, 2, 0);
}
 

@Test
public void simpleClientPooling() {
	ConnectionProvider p = ConnectionProvider.create("simpleClientPooling", 1);
	AtomicReference<Channel> ch1 = new AtomicReference<>();
	AtomicReference<Channel> ch2 = new AtomicReference<>();

	HttpResponseStatus r =
			HttpClient.create(p)
			          .doOnResponse((res, c) -> ch1.set(c.channel()))
			          .wiretap(true)
			          .get()
			          .uri(getURL() + "/status/404")
			          .responseSingle((res, buf) -> buf.thenReturn(res.status()))
			          .block(Duration.ofSeconds(30));

	HttpClient.create(p)
	          .doOnResponse((res, c) -> ch2.set(c.channel()))
	          .wiretap(true)
	          .get()
	          .uri(getURL() + "/status/404")
	          .responseSingle((res, buf) -> buf.thenReturn(res.status()))
	          .block(Duration.ofSeconds(30));

	AtomicBoolean same = new AtomicBoolean();

	same.set(ch1.get() == ch2.get());

	Assert.assertTrue(same.get());

	Assert.assertEquals(r, HttpResponseStatus.NOT_FOUND);
	p.dispose();
}
 

@Test
public void testMaxActiveStreams_1() throws Exception {
	doTestMaxActiveStreams(HttpClient.create(), 1, 1, 1);

	ConnectionProvider provider = ConnectionProvider.create("testMaxActiveStreams_1", 1);
	doTestMaxActiveStreams(HttpClient.create(provider), 1, 1, 1);
	provider.disposeLater()
	        .block();

	doTestMaxActiveStreams(HttpClient.newConnection(), 1, 1, 1);
}
 

@Test
public void testIssue361() {
	disposableServer =
			HttpServer.create()
			          .port(0)
			          .handle((req, res) -> req.receive()
			                                   .aggregate()
			                                   .asString()
			          .flatMap(s -> res.sendString(Mono.just(s))
			                           .then()))
			          .bindNow();

	assertThat(disposableServer).isNotNull();

	ConnectionProvider connectionProvider = ConnectionProvider.create("testIssue361", 1);
	HttpClient client = createHttpClientForContextWithPort(connectionProvider);

	String response = client.post()
	                        .uri("/")
	                        .send(ByteBufFlux.fromString(Mono.just("test")
	                                         .then(Mono.error(new Exception("error")))))
	                        .responseContent()
	                        .aggregate()
	                        .asString()
	                        .onErrorResume(t -> Mono.just(t.getMessage()))
	                        .block(Duration.ofSeconds(30));

	assertThat(response).isEqualTo("error");

	response = client.post()
	                 .uri("/")
	                 .send(ByteBufFlux.fromString(Mono.just("test")))
	                 .responseContent()
	                 .aggregate()
	                 .asString()
	                 .block(Duration.ofSeconds(30));

	assertThat(response).isEqualTo("test");

	connectionProvider.dispose();
}
 

@Test
public void testChannelGroupClosesAllConnections() throws Exception {
	disposableServer =
			HttpServer.create()
			          .port(0)
			          .route(r -> r.get("/never",
			                  (req, res) -> res.sendString(Mono.never()))
			              .get("/delay10",
			                  (req, res) -> res.sendString(Mono.just("test")
			                                                   .delayElement(Duration.ofSeconds(10))))
			              .get("/delay1",
			                  (req, res) -> res.sendString(Mono.just("test")
			                                                   .delayElement(Duration.ofSeconds(1)))))
			          .wiretap(true)
			          .bindNow(Duration.ofSeconds(30));

	ConnectionProvider connectionProvider =
			ConnectionProvider.create("testChannelGroupClosesAllConnections", Integer.MAX_VALUE);

	ChannelGroup group = new DefaultChannelGroup(new DefaultEventExecutor());

	CountDownLatch latch1 = new CountDownLatch(3);
	CountDownLatch latch2 = new CountDownLatch(3);

	HttpClient client = createHttpClientForContextWithAddress(connectionProvider);

	Flux.just("/never", "/delay10", "/delay1")
	    .flatMap(s ->
	            client.doOnConnected(c -> {
	                          c.onDispose()
	                           .subscribe(null, null, latch2::countDown);
	                          group.add(c.channel());
	                          latch1.countDown();
	                      })
	                  .get()
	                  .uri(s)
	                  .responseContent()
	                  .aggregate()
	                  .asString())
	    .subscribe();

	assertThat(latch1.await(30, TimeUnit.SECONDS)).isTrue();

	Mono.whenDelayError(FutureMono.from(group.close()), connectionProvider.disposeLater())
	    .block(Duration.ofSeconds(30));

	assertThat(latch2.await(30, TimeUnit.SECONDS)).isTrue();
}
 

private void doTestIssue600(boolean withLoop) {
	DisposableServer server =
			TcpServer.create()
			         .port(0)
			         .handle((req, res) -> res.send(req.receive()
			                                           .retain()
			                                           .delaySubscription(Duration.ofSeconds(1))))
			         .wiretap(true)
			         .bindNow();

	ConnectionProvider pool = ConnectionProvider.create("doTestIssue600", 10);
	LoopResources loop = LoopResources.create("test", 4, true);
	TcpClient client;
	if (withLoop) {
		client =
				TcpClient.create(pool)
				         .remoteAddress(server::address)
				         .runOn(loop);
	}
	else {
		client =
				TcpClient.create(pool)
				         .remoteAddress(server::address);
	}

	Set<String> threadNames = new ConcurrentSkipListSet<>();
	StepVerifier.create(
			Flux.range(1,4)
			    .flatMap(i ->
			            client.handle((in, out) -> {
			                threadNames.add(Thread.currentThread().getName());
			                return out.send(Flux.empty());
			            })
			            .connect()))
	            .expectNextCount(4)
	            .expectComplete()
	            .verify(Duration.ofSeconds(30));

	pool.dispose();
	loop.dispose();
	server.disposeNow();

	Assertions.assertThat(threadNames.size()).isGreaterThan(1);
}