Java NettyContext.dispose方法代码示例

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void nonContentStatusCodes() {
	NettyContext server =
			HttpServer.create(ops -> ops.host("localhost"))
			          .newRouter(r -> r.get("/204-1", (req, res) -> res.status(HttpResponseStatus.NO_CONTENT)
			                                                           .sendHeaders())
			                           .get("/204-2", (req, res) -> res.status(HttpResponseStatus.NO_CONTENT))
			                           .get("/205-1", (req, res) -> res.status(HttpResponseStatus.RESET_CONTENT)
			                                                           .sendHeaders())
			                           .get("/205-2", (req, res) -> res.status(HttpResponseStatus.RESET_CONTENT))
			                           .get("/304-1", (req, res) -> res.status(HttpResponseStatus.NOT_MODIFIED)
			                                                           .sendHeaders())
			                           .get("/304-2", (req, res) -> res.status(HttpResponseStatus.NOT_MODIFIED)))
			          .block(Duration.ofSeconds(30));

	checkResponse("/204-1", server.address());
	checkResponse("/204-2", server.address());
	checkResponse("/205-1", server.address());
	checkResponse("/205-2", server.address());
	checkResponse("/304-1", server.address());
	checkResponse("/304-2", server.address());

	server.dispose();
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
private void assertSendFile(Function<HttpServerResponse, NettyOutbound> fn) {
	NettyContext context =
			HttpServer.create(opt -> opt.host("localhost"))
			          .newHandler((req, resp) -> fn.apply(resp))
			          .block();


	HttpClientResponse response =
			HttpClient.create(opt -> opt.connectAddress(() -> context.address()))
			          .get("/foo")
			          .block(Duration.ofSeconds(120));

	context.dispose();
	context.onClose().block();

	String body = response.receive().aggregate().asString(StandardCharsets.UTF_8).block();

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

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
private void doTestPublisherSenderOnCompleteFlushInProgress(boolean useScheduler) {
	NettyContext server =
			HttpServer.create(0)
			          .newHandler((req, res) ->
			                  req.receive()
			                     .asString()
			                     .doOnNext(System.err::println)
			                     .then(res.status(200).sendHeaders().then()))
			          .block(Duration.ofSeconds(30));

	Flux<String> flux = Flux.range(1, 257).map(count -> count + "");
	if (useScheduler) {
		flux.publishOn(Schedulers.single());
	}
	Mono<HttpClientResponse> client =
			HttpClient.create(server.address().getPort())
			          .post("/", req -> req.sendString(flux));

	StepVerifier.create(client)
	            .expectNextMatches(res -> {
	                res.dispose();
	                return res.status().code() == 200;
	            })
	            .expectComplete()
	            .verify(Duration.ofSeconds(30));

	server.dispose();
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void testConnectionCloseOnServerError() throws Exception {
	Flux<String> content =
			Flux.range(1, 3)
			    .doOnNext(i -> {
			        if (i == 3) {
			            throw new RuntimeException("test");
			        }
			    })
			    .map(i -> "foo " + i);

	NettyContext server =
			HttpServer.create(0)
			          .newHandler((req, res) -> res.sendString(content))
			          .block(Duration.ofSeconds(30));

	HttpClientResponse r =
			HttpClient.create(ops -> ops.port(server.address().getPort()))
			          .get("/")
			          .block(Duration.ofSeconds(30));

	ByteBufFlux response = r.receive();

	StepVerifier.create(response)
	            .expectNextCount(2)
	            .expectError(IOException.class)
	            .verify(Duration.ofSeconds(30));

	FutureMono.from(r.context().channel().closeFuture()).block(Duration.ofSeconds(30));

	r.dispose();
	server.dispose();
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test(timeout = 10000)
public void testHang() throws Exception {
	NettyContext httpServer = HttpServer
			.create(opts -> opts.host("0.0.0.0").port(0))
			.newRouter(r -> r.get("/data", (request, response) -> {
				return response.send(Mono.empty());
			})).block(Duration.ofSeconds(30));
	httpServer.dispose();
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void httpStatusCode404IsHandledByTheClient() {
	NettyContext server =
			HttpServer.create(0)
			          .newRouter(r -> r.post("/test", (req, res) -> res.send(req.receive()
			                                                                    .log("server-received"))))
			          .block(Duration.ofSeconds(30));

	HttpClient client = HttpClient.create("localhost", server.address().getPort());

	List<String> replyReceived = new ArrayList<>();
	Mono<String> content = client.get("/unsupportedURI", req ->
			                         req.addHeader("Content-Type", "text/plain")
			                            .sendString(Flux.just("Hello")
			                                            .log("client-send"))
			                     )
			                     .flatMapMany(res -> res.receive()
			                                            .asString()
			                                            .log("client-received")
			                                            .doOnNext(s -> replyReceived.add(s)))
			                     .next()
			                     .doOnError(t -> System.err.println("Failed requesting server: " + t.getMessage()));

	StepVerifier.create(content)
			    .expectErrorMatches(t -> t.getMessage().equals("HTTP request failed with code: 404.\nFailing URI: " +
					"/unsupportedURI"))
			    .verify(Duration.ofSeconds(30));

	Assertions.assertThat(replyReceived).isEmpty();

	server.dispose();
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void testRestart() {
	// start a first server with a handler that answers HTTP 200 OK
	NettyContext context = HttpServer.create(8080)
	                                 .newHandler((req, resp) -> resp.status(200)
	                                                                .send().log())
	                                 .block();

	HttpClientResponse response = HttpClient.create(8080).get("/").block();

	// checking the response status, OK
	assertThat(response.status().code()).isEqualTo(200);
	// dispose the Netty context and wait for the channel close
	response.dispose();
	context.dispose();
	context.onClose().block();

	//REQUIRED - bug pool does not detect/translate properly lifecycle
	HttpResources.reset();

	// create a totally new server instance, with a different handler that answers HTTP 201
	context = HttpServer.create(8080)
	                    .newHandler((req, resp) -> resp.status(201).send()).block();

	response = HttpClient.create(8080).get("/").block();

	// fails, response status is 200 and debugging shows the the previous handler is called
	assertThat(response.status().code()).isEqualTo(201);
	response.dispose();
	context.dispose();
	context.onClose().block();
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void testIssue462() throws InterruptedException {

	final CountDownLatch countDownLatch = new CountDownLatch(1);

	NettyContext server = TcpServer.create(0)
	                               .newHandler((in, out) -> {
		                             in.receive()
		                               .log("channel")
		                               .subscribe(trip -> {
			                               countDownLatch.countDown();
		                               });
		                             return Flux.never();
	                             })
	                               .block(Duration.ofSeconds(30));

	System.out.println("PORT +" + server.address()
	                                    .getPort());

	NettyContext client = TcpClient.create(server.address()
	                                             .getPort())
	                               .newHandler((in, out) -> out.sendString(Flux.just(
			                             "test")))
	                               .block(Duration.ofSeconds(30));

	client.dispose();
	server.dispose();

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

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
@Ignore
public void pipelined() throws Exception {
	NettyContext x = TcpServer.create("localhost", 0)
	                          .newHandler((in, out) -> out.context(c -> c.addHandlerFirst(new
			                          HttpResponseEncoder()))
	                                                      .sendObject(Flux.just(
			                                                      response(),
			                                                      response()))
	                                                      .neverComplete())
	                          .block(Duration.ofSeconds(30));

	PoolResources pool = PoolResources.fixed("test", 1);

	HttpClient.create(opts -> opts.host("localhost")
	                              .port(x.address().getPort())
	                              .poolResources(pool))
	                    .get("/")
	                    .flatMap(r -> {
	                        r.dispose();
	                        return Mono.just(r.status().code());
	                    })
	                    .log()
	                    .block(Duration.ofSeconds(30));

	try {
		HttpClient.create(opts -> opts.host("localhost")
		                              .port(x.address().getPort())
		                              .poolResources(pool))
		          .get("/")
		          .log()
		          .block(Duration.ofSeconds(30));
	}
	catch (AbortedException ae) {
		return;
	}

	x.dispose();
	Assert.fail("Not aborted");
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void test() {
	NettyContext context =
			HttpServer.create(opt -> opt.host("localhost"))
			          .newRouter(r -> r.put("/201", (req, res) -> res.addHeader("Content-Length", "0")
			                                                         .status(HttpResponseStatus.CREATED)
			                                                         .sendHeaders())
			                           .put("/204", (req, res) -> res.status(HttpResponseStatus.NO_CONTENT)
			                                                         .sendHeaders())
			                           .get("/200", (req, res) -> res.addHeader("Content-Length", "0")
			                                                         .sendHeaders()))
			          .block(Duration.ofSeconds(30));

	HttpClientResponse response1 =
			createHttpClientForContext(context)
			          .put("/201", req -> req.sendHeaders())
			          .block();

	HttpClientResponse response2 =
			createHttpClientForContext(context)
			          .put("/204", req -> req.sendHeaders())
			          .block(Duration.ofSeconds(30));

	HttpClientResponse response3 =
			createHttpClientForContext(context)
			          .get("/200", req -> req.sendHeaders())
			          .block(Duration.ofSeconds(30));

	response1.dispose();
	response2.dispose();
	response3.dispose();
	context.dispose();
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void consumerSpecAssignsEventHandlers()
		throws InterruptedException, IOException {
	final CountDownLatch latch = new CountDownLatch(2);
	final CountDownLatch close = new CountDownLatch(1);
	final AtomicLong totalDelay = new AtomicLong();
	final long start = System.currentTimeMillis();

	TcpClient client =
			TcpClient.create(opts -> opts.host("localhost").port(timeoutServerPort));

	NettyContext s = client.newHandler((in, out) -> {
		in.onReadIdle(500, () -> {
			  totalDelay.addAndGet(System.currentTimeMillis() - start);
			  latch.countDown();
		})
		  .context()
		  .onClose(close::countDown);

		out.onWriteIdle(500, () -> {
			totalDelay.addAndGet(System.currentTimeMillis() - start);
			latch.countDown();
		});

		return Mono.delay(Duration.ofSeconds(3))
		           .then()
		           .log();
	})
	                       .block(Duration.ofSeconds(30));

	assertTrue("latch was counted down", latch.await(5, TimeUnit.SECONDS));
	assertTrue("close was counted down", close.await(30, TimeUnit.SECONDS));
	assertThat("totalDelay was >500ms", totalDelay.get(), greaterThanOrEqualTo(500L));
	s.dispose();
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void userIssue() throws Exception {
	final PoolResources pool = PoolResources.fixed("local", 1);
	CountDownLatch latch = new CountDownLatch(3);
	Set<String> localAddresses = ConcurrentHashMap.newKeySet();
	NettyContext serverContext = HttpServer.create(8080)
	                                       .newRouter(r -> r.post("/",
			                                       (req, resp) -> req.receive()
			                                                         .asString()
			                                                         .flatMap(data -> {
				                                                         latch.countDown();
				                                                         return resp.status(
						                                                         200)
				                                                                    .send();
			                                                         })))
	                                       .block();

	final HttpClient client = HttpClient.create(options -> {
		options.poolResources(pool);
		options.connectAddress(() -> new InetSocketAddress(8080));
	});
	Flux.just("1", "2", "3")
	    .concatMap(data -> client.post("/", req -> req.sendString(Flux.just(data)))
	                           .doOnNext(r -> r.receive()
	                                           .subscribe()))
	    .subscribe(response -> {
		    localAddresses.add(response.channel()
		                               .localAddress()
		                               .toString());
	    });

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

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void test() {
	NettyContext server = HttpServer.create(0)
	                                .newRouter(httpServerRoutes -> httpServerRoutes.get(
			                                "/",
			                                (httpServerRequest, httpServerResponse) -> {
				                                return httpServerResponse.sendString(
						                                Mono.error(new IllegalArgumentException()));
			                                }))
	                                .block(Duration.ofSeconds(30));

	HttpClient client = HttpClient.create(opt -> opt.host("localhost")
	                                                .port(server.address().getPort())
	                                                .disablePool());

	HttpClientResponse r = client.get("/")
	                             .block(Duration.ofSeconds(30));

	Mono<List<String>> result = r.receive()
	                    .asString(StandardCharsets.UTF_8)
	                    .collectList();

	StepVerifier.create(result)
	            .expectError(IOException.class)
	            .verify(Duration.ofSeconds(30));

	System.out.println("END");

	FutureMono.from(r.context().channel().closeFuture()).block(Duration.ofSeconds(30));

	r.dispose();
	server.dispose();
}
 

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
public void sendFileSecure()
		throws CertificateException, SSLException, URISyntaxException {
	Path largeFile = Paths.get(getClass().getResource("/largeFile.txt").toURI());
	SelfSignedCertificate ssc = new SelfSignedCertificate();
	SslContext sslServer = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
	SslContext sslClient = SslContextBuilder.forClient().trustManager(ssc.cert()).build();

	NettyContext context =
			HttpServer.create(opt -> opt.sslContext(sslServer))
			          .newHandler((req, resp) -> resp.sendFile(largeFile))
			          .block();


	HttpClientResponse response =
			HttpClient.create(opt -> opt.port(context.address().getPort())
			                            .sslContext(sslClient))
			          .get("/foo")
			          .block(Duration.ofSeconds(120));

	context.dispose();
	context.onClose().block();

	String body = response.receive().aggregate().asString(StandardCharsets.UTF_8).block();

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

import reactor.ipc.netty.NettyContext; //导入方法依赖的package包/类
@Test
@Ignore
public void supportsReceivingDatagrams() throws InterruptedException {
	final int port = SocketUtils.findAvailableUdpPort();
	final CountDownLatch latch = new CountDownLatch(4);

	final NettyContext server = UdpServer.create(port)
	                                     .newHandler((in, out) -> {
		                                   in.receive()
		                                     .asByteArray()
		                                     .log()
		                                     .subscribe(bytes -> {
			                                     if (bytes.length == 1024) {
				                                     latch.countDown();
			                                     }
		                                     });
		                                   return Flux.never();
	                                   })
	                                     .doOnSuccess(v -> {
		                                   try {
			                                   DatagramChannel udp =
					                                   DatagramChannel.open();
			                                   udp.configureBlocking(true);
			                                   udp.connect(new InetSocketAddress(
					                                   InetAddress.getLocalHost(),
					                                   port));

			                                   byte[] data = new byte[1024];
			                                   new Random().nextBytes(data);
			                                   for (int i = 0; i < 4; i++) {
				                                   udp.write(ByteBuffer.wrap(data));
			                                   }

			                                   udp.close();
		                                   }
		                                   catch (IOException e) {
			                                   e.printStackTrace();
		                                   }
	                                   })
	                                     .block(Duration.ofSeconds(30));

	assertThat("latch was counted down", latch.await(10, TimeUnit.SECONDS));
	server.dispose();
}