Java Code Examples for reactor.netty.DisposableServer#disposeNow()

@Test
public void testIssue282() {
	DisposableServer server =
			HttpServer.create()
			          .compress(2048)
			          .port(0)
			          .handle((req, res) -> res.sendString(Mono.just("testtesttesttesttest")))
			          .bindNow();

	Mono<String> response =
			HttpClient.create()
			          .port(server.port())
			          .get()
			          .uri("/")
			          .responseContent()
			          .aggregate()
			          .asString();

	StepVerifier.create(response)
	            .expectNextMatches("testtesttesttesttest"::equals)
	            .expectComplete()
	            .verify();

	server.disposeNow();
}
 

@Test
public void testIssue462() throws InterruptedException {

	final CountDownLatch countDownLatch = new CountDownLatch(1);

	DisposableServer server = TcpServer.create()
	                                   .port(0)
	                                   .handle((in, out) -> {
	                                       in.receive()
	                                         .log("channel")
	                                         .subscribe(trip -> countDownLatch.countDown());
	                                       return Flux.never();
	                                   })
	                                   .wiretap(true)
	                                   .bindNow();

	assertNotNull(server);

	System.out.println("PORT +" + server.port());

	Connection client = TcpClient.create()
	                             .port(server.port())
	                             .handle((in, out) -> out.sendString(Flux.just("test")))
	                             .wiretap(true)
	                             .connectNow();

	assertNotNull(client);

	assertThat("Latch was counted down", countDownLatch.await(5, TimeUnit.SECONDS));

	client.disposeNow();
	server.disposeNow();
}
 

@Test
public void testIssue606() {
	final int serverPort = SocketUtils.findAvailableTcpPort();

	DisposableServer server =
			HttpServer.create()
			          .port(serverPort)
			          .host("localhost")
			          .handle((req, res) -> res.sendRedirect("http://localhost:" + serverPort))
			          .wiretap(true)
			          .bindNow();

	AtomicInteger followRedirects = new AtomicInteger(0);
	HttpClient.create()
	          .remoteAddress(server::address)
	          .wiretap(true)
	          .followRedirect((req, res) -> {
	              boolean result = req.redirectedFrom().length < 4;
	              if (result) {
	                  followRedirects.getAndIncrement();
	              }
	              return result;
	          })
	          .get()
	          .uri("/")
	          .responseContent()
	          .blockLast();

	server.disposeNow();

	assertThat(followRedirects.get()).isEqualTo(4);
}
 

@Test
public void testRetryOnDifferentAddress() throws Exception {
	DisposableServer server =
			TcpServer.create()
			         .port(0)
			         .wiretap(true)
			         .handle((req, res) -> res.sendString(Mono.just("test")))
			         .bindNow();

	final CountDownLatch latch = new CountDownLatch(1);

	Supplier<SocketAddress> addressSupplier = new Supplier<SocketAddress>() {
		int i = 2;

		@Override
		public SocketAddress get() {
			return new InetSocketAddress("localhost", server.port() + i--);
		}
	};

	Connection  conn =
			TcpClient.create()
			         .remoteAddress(addressSupplier)
			         .doOnConnected(connection -> latch.countDown())
			         .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 100)
			         .handle((in, out) -> Mono.never())
			         .wiretap(true)
			         .connect()
			         .retry()
			         .block(Duration.ofSeconds(30));
	assertNotNull(conn);

	assertTrue(latch.await(30, TimeUnit.SECONDS));

	conn.disposeNow();
	server.disposeNow();
}
 

@Test
public void httpStatusCode404IsHandledByTheClient() {
	DisposableServer server =
			HttpServer.create()
			          .port(0)
			          .route(r -> r.post("/test", (req, res) -> res.send(req.receive()
			                                                                .log("server-received"))))
			          .wiretap(true)
			          .bindNow();

	HttpClient client =
			HttpClient.create()
			          .port(server.port())
			          .wiretap(true);

	Mono<Integer> content = client.headers(h -> h.add("Content-Type", "text/plain"))
			                      .request(HttpMethod.GET)
			                      .uri("/status/404")
			                      .send(ByteBufFlux.fromString(Flux.just("Hello")
			                                                       .log("client-send")))
			                      .responseSingle((res, buf) -> Mono.just(res.status().code()))
			                     .doOnError(t -> System.err.println("Failed requesting server: " + t.getMessage()));

	StepVerifier.create(content)
			    .expectNext(404)
			    .verifyComplete();

	server.disposeNow();
}
 

@Test
public void testIssue1012() throws Exception {
	DisposableServer server =
			HttpServer.create()
			          .port(0)
			          .wiretap(true)
			          .route(r -> r.get("/1", (req, resp) -> resp.sendString(Mono.just("testIssue1012")))
			                       .get("/2", (req, res) -> Mono.error(new RuntimeException("testIssue1012"))))
			          .bindNow();

	DefaultPooledConnectionProvider provider = (DefaultPooledConnectionProvider) ConnectionProvider.create("testIssue1012", 1);
	CountDownLatch latch = new CountDownLatch(1);
	HttpClient client =
			HttpClient.create(provider)
			          .port(server.port())
			          .wiretap(true)
			          .doOnConnected(conn -> conn.channel().closeFuture().addListener(f -> latch.countDown()));

	client.get()
	      .uri("/1")
	      .responseContent()
	      .aggregate()
	      .block(Duration.ofSeconds(30));

	client.get()
	      .uri("/2")
	      .responseContent()
	      .aggregate()
	      .onErrorResume(e -> Mono.empty())
	      .block(Duration.ofSeconds(30));

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

	provider.channelPools.forEach((k, v) -> assertThat(v.metrics().acquiredSize()).isEqualTo(0));

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

@Test
@SuppressWarnings("deprecation")
public void testAddressSupplier() {
	DisposableServer server =
			TcpServer.create()
			         .port(0)
			         .handle((req, res) -> res.send(req.receive()
			                                           .retain()))
			         .wiretap(true)
			         .bindNow();

	Connection conn =
			TcpClient.create()
			         .addressSupplier(server::address)
			         .connectNow();

	conn.outbound()
			.sendString(Mono.just("testAddressSupplier"))
			.then()
			.subscribe();

	String result =
			conn.inbound()
			    .receive()
			    .asString()
			    .blockFirst();

	assertEquals("testAddressSupplier", result);

	conn.disposeNow();
	server.disposeNow();
}
 

private void assertSendFile(Function<HttpServerResponse, NettyOutbound> fn, boolean compression, int compressionSize,
		BiPredicate<HttpServerRequest, HttpServerResponse> compressionPredicate, Consumer<String> bodyAssertion) {
	HttpServer server = HttpServer.create();
	if (compressionPredicate != null) {
		server = server.compress(compressionPredicate);
	}
       if (compressionSize > -1) {
		server = server.compress(compressionSize);
	}
	DisposableServer context =
			customizeServerOptions(server)
			          .handle((req, resp) -> fn.apply(resp))
			          .wiretap(true)
			          .bindNow();

	HttpClient client;
	if (compression) {
		client = HttpClient.create()
		                   .remoteAddress(context::address)
		                   .compress(true);
	}
	else {
		client = HttpClient.create()
		                   .remoteAddress(context::address);
	}
	Mono<String> response =
			customizeClientOptions(client)
			          .wiretap(true)
			          .get()
			          .uri("/foo")
			          .responseSingle((res, byteBufMono) -> byteBufMono.asString(StandardCharsets.UTF_8));

	String body = response.block(Duration.ofSeconds(5));

	context.disposeNow();

	bodyAssertion.accept(body);
}
 

@Test
public void redirectDisabledByDefault() {
	DisposableServer server =
			HttpServer.create()
			          .port(0)
			          .host("localhost")
			          .wiretap(true)
			          .route(r -> r.get("/1", (req, res) -> res.sendRedirect("/3"))
			                       .get("/3", (req, res) -> res.status(200)
			                                                   .sendString(Mono.just("OK"))))
			          .wiretap(true)
			          .bindNow();

	HttpClientResponse response =
			HttpClient.create()
			          .remoteAddress(server::address)
			          .wiretap(true)
			          .get()
			          .uri("/1")
			          .response()
			          .block(Duration.ofSeconds(30));

	assertThat(response).isNotNull();
	assertThat(response.status()).isEqualTo(HttpResponseStatus.FOUND);
	assertThat(response.responseHeaders().get("location")).isEqualTo("/3");

	server.disposeNow();
}
 

@Test
public void exposesRemoteAddress() throws InterruptedException {
	final int port = SocketUtils.findAvailableTcpPort();
	final CountDownLatch latch = new CountDownLatch(1);

	DisposableServer server = TcpServer.create()
	                                   .port(port)
	                                   .handle((in, out) -> {

	    in.withConnection(c -> {
	        InetSocketAddress addr = (InetSocketAddress) c.address();
	        assertNotNull("remote address is not null", addr.getAddress());
	        latch.countDown();
	    });

		return Flux.never();
	                                   })
	                                   .wiretap(true)
	                                   .bindNow();

	assertNotNull(server);

	Connection client = TcpClient.create().port(port)
	                             .handle((in, out) -> out.sendString(Flux.just("Hello World!")))
	                             .wiretap(true)
	                             .connectNow();

	assertNotNull(client);

	assertTrue("Latch was counted down", latch.await(5, TimeUnit.SECONDS));

	client.disposeNow();
	server.disposeNow();
}
 

@Test
public void testProtocolH2SslConfiguration() {
	DisposableServer disposableServer =
			server.protocol(HttpProtocol.H2)
			      .secure(spec -> spec.sslContext(builder))
			      .bindNow();
	assertEquals(2, protocols.size());
	assertTrue(protocols.contains("h2"));
	assertTrue(io.netty.handler.ssl.SslProvider.isAlpnSupported(io.netty.handler.ssl.SslProvider.OPENSSL) ?
	                                       sslContext instanceof OpenSslContext :
	                                       sslContext instanceof JdkSslContext);
	disposableServer.disposeNow();
}
 

@Test
public void testSslConfigurationProtocolH2_1() {
	DisposableServer disposableServer =
			server.secure(spec -> spec.sslContext(builder))
			      .protocol(HttpProtocol.H2)
			      .bindNow();
	assertEquals(2, protocols.size());
	assertTrue(protocols.contains("h2"));
	assertTrue(io.netty.handler.ssl.SslProvider.isAlpnSupported(io.netty.handler.ssl.SslProvider.OPENSSL) ?
	                                       sslContext instanceof OpenSslContext :
	                                       sslContext instanceof JdkSslContext);
	disposableServer.disposeNow();
}
 

@Test
public void testChannelGroupClosesAllConnections() throws Exception {
	MonoProcessor<Void> serverConnDisposed = MonoProcessor.create();

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

	CountDownLatch latch = new CountDownLatch(1);

	DisposableServer boundServer =
			TcpServer.create()
			         .port(0)
			         .doOnConnection(c -> {
			             c.onDispose()
			              .subscribe(serverConnDisposed);
			             group.add(c.channel());
			             latch.countDown();
			         })
			         .wiretap(true)
			         .bindNow();

	TcpClient.create()
	         .remoteAddress(boundServer::address)
	         .wiretap(true)
	         .connect()
	         .subscribe();

	assertTrue(latch.await(30, TimeUnit.SECONDS));

	boundServer.disposeNow();

	FutureMono.from(group.close())
	          .block(Duration.ofSeconds(30));

	serverConnDisposed.block(Duration.ofSeconds(5));
}
 

@Test(timeout = 10000)
public void testHang() {
	DisposableServer httpServer =
			HttpServer.create()
			          .port(0)
			          .host("0.0.0.0")
			          .route(r -> r.get("/data", (request, response) -> response.send(Mono.empty())))
			          .wiretap(true)
			          .bindNow();

	assertNotNull(httpServer);

	httpServer.disposeNow();
}
 

@Test
public void testIssue825_1() {
	int port1 = SocketUtils.findAvailableTcpPort();
	int port2 = SocketUtils.findAvailableTcpPort();

	AtomicReference<Throwable> error = new AtomicReference<>();
	DisposableServer server1 =
			HttpServer.create()
			          .port(port1)
			          .compress(true)
			          .handle((in, out) -> out.send(
			              HttpClient.create()
			                        .port(port2)
			                        .wiretap(true)
			                        .get()
			                        .uri("/")
			                        .responseContent()
			                        .doOnError(error::set)))
			                        // .retain() deliberately not invoked
			                        // so that .release() in FluxReceive.drainReceiver will fail
			                        //.retain()))
			          .wiretap(true)
			          .bindNow();

	DisposableServer server2 =
			HttpServer.create()
			          .port(port2)
			          .handle((in, out) -> out.sendString(Mono.just("reply")))
			          .wiretap(true)
			          .bindNow();

	StepVerifier.create(
	        HttpClient.create()
	                  .port(port1)
	                  .wiretap(true)
	                  .compress(true)
	                  .get()
	                  .uri("/")
	                  .responseContent()
	                  .aggregate()
	                  .asString())
	            .expectError()
	            .verify(Duration.ofSeconds(30));

	assertThat(error.get()).isNotNull()
	                       .isInstanceOf(RuntimeException.class);

	server1.disposeNow();
	server2.disposeNow();
}
 

private void assertSendFile(Function<NettyOutbound, NettyOutbound> fn) {
	DisposableServer context =
			TcpServer.create()
			         .handle((in, out) ->
			                 in.receive()
			                   .asString()
			                   .flatMap(word -> "GOGOGO".equals(word) ?
			                            fn.apply(out).then() :
			                            out.sendString(Mono.just("NOPE"))))
			         .wiretap(true)
			         .bindNow();

	assertNotNull(context);

	MonoProcessor<String> m1 = MonoProcessor.create();
	MonoProcessor<String> m2 = MonoProcessor.create();

	Connection client1 =
			TcpClient.create()
			         .port(context.port())
			         .handle((in, out) -> {
			             in.receive()
			               .asString()
			               .log("-----------------CLIENT1")
			               .subscribe(m1::onNext);

			             return out.sendString(Mono.just("gogogo"))
			                       .neverComplete();
			         })
			         .wiretap(true)
			         .connectNow();

	Connection client2 =
			TcpClient.create()
			         .port(context.port())
			         .handle((in, out) -> {
			             in.receive()
			               .asString(StandardCharsets.UTF_8)
			               .take(2)
			               .reduceWith(String::new, String::concat)
			               .log("-----------------CLIENT2")
			               .subscribe(m2::onNext);

			             return out.sendString(Mono.just("GOGOGO"))
			                       .neverComplete();
			         })
			         .wiretap(true)
			         .connectNow();

	assertNotNull(client2);

	String client1Response = m1.block();
	String client2Response = m2.block();

	client1.disposeNow();
	client2.disposeNow();
	context.disposeNow();

	Assertions.assertThat(client1Response).isEqualTo("NOPE");

	Assertions.assertThat(client2Response)
	          .startsWith("This is an UTF-8 file that is larger than 1024 bytes. " + "It contains accents like é.")
	          .contains("1024 mark here ->")
	          .contains("<- 1024 mark here")
	          .endsWith("End of File");
}
 

@Test
public void tcpServerHandlesJsonPojosOverSsl() throws Exception {
	final CountDownLatch latch = new CountDownLatch(2);

	SelfSignedCertificate cert = new SelfSignedCertificate();
	SslContextBuilder serverOptions = SslContextBuilder.forServer(cert.certificate(), cert.privateKey())
	                                                   .sslProvider(SslProvider.JDK);
	SslContext clientOptions = SslContextBuilder.forClient()
	                                            .trustManager(InsecureTrustManagerFactory.INSTANCE)
	                                            .sslProvider(SslProvider.JDK)
	                                            .build();

	log.debug("Using SslContext: {}", clientOptions);

	final TcpServer server =
			TcpServer.create()
			         .host("localhost")
			         .secure(sslContextSpec -> sslContextSpec.sslContext(serverOptions));

	ObjectMapper m = new ObjectMapper();

	DisposableServer connectedServer = server.handle((in, out) -> {
		in.receive()
		  .asByteArray()
		  .map(bb -> {
		      try {
		          return m.readValue(bb, Pojo.class);
		      }
		      catch (IOException io) {
		          throw Exceptions.propagate(io);
		      }
		  })
		  .log("conn")
		  .subscribe(data -> {
		      if ("John Doe".equals(data.getName())) {
		          latch.countDown();
		      }
		  });

		return out.sendString(Mono.just("Hi"))
		          .neverComplete();
	})
	                                         .wiretap(true)
	                                         .bindNow();

	assertNotNull(connectedServer);

	final TcpClient client = TcpClient.create()
	                                  .host("localhost")
	                                  .port(connectedServer.port())
	                                  .secure(spec -> spec.sslContext(clientOptions));

	Connection connectedClient = client.handle((in, out) -> {
		//in
		in.receive()
		  .asString()
		  .log("receive")
		  .subscribe(data -> {
		      if (data.equals("Hi")) {
		          latch.countDown();
		      }
		  });

		//out
		return out.send(Flux.just(new Pojo("John" + " Doe"))
		                    .map(s -> {
		                        try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
		                            m.writeValue(os, s);
		                            return out.alloc()
		                                      .buffer()
		                                      .writeBytes(os.toByteArray());
		                        }
		                        catch (IOException ioe) {
		                            throw Exceptions.propagate(ioe);
		                        }
		                    }))
		          .neverComplete();
	})
	                                   .wiretap(true)
	                                   .connectNow();

	assertNotNull(connectedClient);

	assertTrue("Latch was counted down", latch.await(5, TimeUnit.SECONDS));

	connectedClient.disposeNow();
	connectedServer.disposeNow();
}
 

@Test
@SuppressWarnings("FutureReturnValueIgnored")
public void testHalfClosedConnection() throws Exception {
	DisposableServer server =
			TcpServer.create()
			         .port(0)
			         .childOption(ChannelOption.ALLOW_HALF_CLOSURE, true)
			         .wiretap(true)
			         .handle((in, out) -> in.receive()
			                                .asString()
			                                .doOnNext(s -> {
			                                    if (s.endsWith("257\n")) {
			                                        out.sendString(Mono.just("END")
			                                                           .delayElement(Duration.ofMillis(100)))
			                                           .then()
			                                           .subscribe();
			                                    }
			                                })
			                                .then())
			         .bindNow();

	Connection conn =
			TcpClient.create()
			         .remoteAddress(server::address)
			         .wiretap(true)
			         .connectNow();

	CountDownLatch latch = new CountDownLatch(1);
	conn.inbound()
	    .receive()
	    .asString()
	    .subscribe(s -> {
	        if ("END".equals(s)) {
	            latch.countDown();
	        }
	    });

	conn.outbound()
	    .sendString(Flux.range(1, 257).map(count -> count + "\n"))
	    .then()
	    .subscribe(null, null, () -> ((io.netty.channel.socket.SocketChannel) conn.channel()).shutdownOutput()); // FutureReturnValueIgnored

	assertTrue(latch.await(30, TimeUnit.SECONDS));

	conn.disposeNow();
	server.disposeNow();
}
 

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);
}
 

@Test
public void testByteBufsReleasedWhenTimeout() {
	byte[] content = new byte[1024*8];
	Random rndm = new Random();
	rndm.nextBytes(content);

	DisposableServer server1 =
			HttpServer.create()
			          .port(0)
			          .route(routes ->
			                     routes.get("/target", (req, res) ->
			                           req.receive()
			                              .thenMany(res.sendByteArray(Flux.just(content)
			                                                              .delayElements(Duration.ofMillis(100))))))
			          .bindNow();

	DisposableServer server2 =
			HttpServer.create()
			          .port(0)
			          .route(routes ->
			                     routes.get("/forward", (req, res) ->
			                           HttpClient.create()
			                                     .port(server1.port())
			                                     .get()
			                                     .uri("/target")
			                                     .responseContent()
			                                     .aggregate()
			                                     .asString()
			                                     .log()
			                                     .timeout(Duration.ofMillis(50))
			                                     .then()))
			          .bindNow();

	Flux.range(0, 50)
	    .flatMap(i -> HttpClient.create()
	                            .port(server2.port())
	                            .get()
	                            .uri("/forward")
	                            .responseContent()
	                            .log()
	                            .onErrorResume(t -> Mono.empty()))
	    .blockLast(Duration.ofSeconds(15));

	server1.disposeNow();
	server2.disposeNow();
}