Examples with DisposableServer reactor.netty.DisposableServer used on opensource projects

Example 91 with DisposableServer

use of reactor.netty.DisposableServer in project reactor-netty by reactor.

the class HttpRedirectTest method testLastLocationSetToResourceUrlOnRedirect.

@Test
void testLastLocationSetToResourceUrlOnRedirect() {
    final String redirectPath = "/redirect";
    final String destinationPath = "/destination";
    final String responseContent = "Success";
    Http11SslContextSpec serverSslContextSpec = Http11SslContextSpec.forServer(ssc.certificate(), ssc.privateKey());
    DisposableServer redirectServer = null;
    DisposableServer initialServer = null;
    try {
        redirectServer = createServer().route(r -> r.get(redirectPath, (req, res) -> res.sendRedirect(destinationPath)).get(destinationPath, (req, res) -> res.sendString(Mono.just(responseContent)))).secure(spec -> spec.sslContext(serverSslContextSpec)).bindNow();
        final int redirectServerPort = redirectServer.port();
        initialServer = createServer().handle((req, res) -> res.sendRedirect("https://localhost:" + redirectServerPort + destinationPath)).bindNow();
        Http11SslContextSpec clientSslContextSpec = Http11SslContextSpec.forClient().configure(builder -> builder.trustManager(InsecureTrustManagerFactory.INSTANCE));
        final String requestUri = "http://localhost:" + initialServer.port();
        StepVerifier.create(HttpClient.create().wiretap(true).followRedirect(true).secure(spec -> spec.sslContext(clientSslContextSpec)).get().uri(requestUri).response((res, conn) -> Mono.justOrEmpty(res.resourceUrl()))).expectNext("https://localhost:" + redirectServer.port() + destinationPath).expectComplete().verify(Duration.ofSeconds(30));
    } finally {
        if (redirectServer != null) {
            redirectServer.disposeNow();
        }
        if (initialServer != null) {
            initialServer.disposeNow();
        }
    }
}

Example 92 with DisposableServer

use of reactor.netty.DisposableServer in project reactor-netty by reactor.

the class HttpRedirectTest method redirectTests.

private void redirectTests(String url) {
    AtomicInteger counter = new AtomicInteger(1);
    disposableServer = createServer().handle((req, res) -> {
        if (req.uri().contains("/login") && req.method().equals(HttpMethod.POST) && counter.getAndDecrement() > 0) {
            return res.sendRedirect(url);
        } else {
            return res.status(200).send();
        }
    }).bindNow();
    ConnectionProvider pool = ConnectionProvider.create("redirectTests", 1);
    HttpClient client = createClient(pool, disposableServer::address);
    Flux.range(0, 100).concatMap(i -> client.followRedirect(true).post().uri("/login").responseContent().then()).blockLast(Duration.ofSeconds(30));
}

Example 93 with DisposableServer

use of reactor.netty.DisposableServer in project reactor-netty by reactor.

the class DefaultPooledConnectionProviderTest method testIssue951_MaxPendingAcquire.

@Test
void testIssue951_MaxPendingAcquire() throws InterruptedException {
    DisposableServer server = TcpServer.create().port(0).handle((in, out) -> out.sendString(Mono.just("test").delayElement(Duration.ofMillis(100)))).wiretap(true).bindNow();
    DefaultPooledConnectionProvider provider = (DefaultPooledConnectionProvider) ConnectionProvider.builder("testIssue951_MaxPendingAcquire").maxConnections(1).pendingAcquireTimeout(Duration.ofMillis(30)).pendingAcquireMaxCount(1).build();
    CountDownLatch latch = new CountDownLatch(2);
    try {
        AtomicReference<InstrumentedPool<PooledConnection>> pool = new AtomicReference<>();
        List<? extends Signal<? extends Connection>> list = Flux.range(0, 3).flatMapDelayError(i -> TcpClient.create(provider).port(server.port()).doOnConnected(conn -> {
            ConcurrentMap<PooledConnectionProvider.PoolKey, InstrumentedPool<PooledConnection>> pools = provider.channelPools;
            pool.set(pools.get(pools.keySet().toArray()[0]));
        }).doOnDisconnected(conn -> latch.countDown()).handle((in, out) -> in.receive().then()).wiretap(true).connect().materialize(), 256, 32).collectList().doFinally(fin -> latch.countDown()).block(Duration.ofSeconds(30));
        assertThat(latch.await(30, TimeUnit.SECONDS)).as("latch 30s").isTrue();
        assertThat(list).isNotNull().hasSize(3);
        int onNext = 0;
        int onErrorTimeout = 0;
        int onErrorPendingAcquire = 0;
        String msg1 = "Pool#acquire(Duration) has been pending for more than the configured timeout of 30ms";
        String msg2 = "Pending acquire queue has reached its maximum size of 1";
        for (int i = 0; i < 3; i++) {
            Signal<? extends Connection> signal = list.get(i);
            if (signal.isOnNext()) {
                onNext++;
            } else if (signal.getThrowable() instanceof TimeoutException && msg1.equals(signal.getThrowable().getMessage())) {
                onErrorTimeout++;
            } else if (signal.getThrowable() instanceof PoolAcquirePendingLimitException && msg2.equals(signal.getThrowable().getMessage())) {
                onErrorPendingAcquire++;
            }
        }
        assertThat(onNext).isEqualTo(1);
        assertThat(onErrorTimeout).isEqualTo(1);
        assertThat(onErrorPendingAcquire).isEqualTo(1);
        assertThat(pool.get().metrics().acquiredSize()).as("currently acquired").isEqualTo(0);
        assertThat(pool.get().metrics().idleSize()).as("currently idle").isEqualTo(0);
    } finally {
        server.disposeNow();
        provider.dispose();
    }
}

Example 94 with DisposableServer

use of reactor.netty.DisposableServer in project reactor-netty by reactor.

the class DefaultPooledConnectionProviderTest method doTestIssue1790.

private void doTestIssue1790(boolean fifoPool) {
    DefaultPooledConnectionProvider provider;
    if (fifoPool) {
        provider = (DefaultPooledConnectionProvider) ConnectionProvider.builder("testIssue1790").maxConnections(1).fifo().build();
    } else {
        provider = (DefaultPooledConnectionProvider) ConnectionProvider.builder("testIssue1790").maxConnections(1).lifo().build();
    }
    DisposableServer disposableServer = TcpServer.create().port(0).wiretap(true).bindNow();
    Connection connection = null;
    try {
        connection = TcpClient.create(provider).port(disposableServer.port()).wiretap(true).connectNow();
        assertThat(provider.channelPools).hasSize(1);
        @SuppressWarnings({ "unchecked", "rawtypes" }) InstrumentedPool<DefaultPooledConnectionProvider.PooledConnection> channelPool = provider.channelPools.values().toArray(new InstrumentedPool[0])[0];
        assertThat(channelPool.metrics()).withFailMessage("Reactor-netty relies on Reactor-pool instrumented pool.metrics()" + " to be the pool instance itself, got <%s> and <%s>", channelPool.metrics(), channelPool).isSameAs(channelPool);
    } finally {
        if (connection != null) {
            connection.disposeNow();
        }
        disposableServer.disposeNow();
        provider.disposeLater().block(Duration.ofSeconds(5));
    }
}

Example 95 with DisposableServer

use of reactor.netty.DisposableServer in project reactor-netty by reactor.

the class TcpClientTests method testRetryOnDifferentAddress.

@Test
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));
    assertThat(conn).isNotNull();
    assertThat(latch.await(30, TimeUnit.SECONDS)).as("latch await").isTrue();
    conn.disposeNow();
    server.disposeNow();
}