Examples with ChannelInboundHandlerAdapter org.apache.flink.shaded.netty4.io.netty.channel.ChannelInboundHandlerAdapter used on opensource projects

Example 41 with ChannelInboundHandlerAdapter

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInboundHandlerAdapter in project netty by netty.

the class OcspTest method testClientException.

/**
 * Testing what happens if the {@link OcspClientCallback} throws an {@link Exception}.
 *
 * The exception should bubble up on the client side and the connection should get closed.
 */
private static void testClientException(SslProvider sslProvider) throws Exception {
    final AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
    final CountDownLatch latch = new CountDownLatch(1);
    ChannelInboundHandlerAdapter clientHandler = new ChannelInboundHandlerAdapter() {

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            try {
                causeRef.set(cause);
            } finally {
                latch.countDown();
            }
        }
    };
    final OcspTestException clientException = new OcspTestException("testClientException");
    byte[] response = newOcspResponse();
    OcspClientCallback callback = new OcspClientCallback() {

        @Override
        public boolean verify(byte[] response) throws Exception {
            throw clientException;
        }
    };
    handshake(sslProvider, latch, null, response, clientHandler, callback);
    assertSame(clientException, causeRef.get());
}

Example 42 with ChannelInboundHandlerAdapter

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInboundHandlerAdapter in project netty by netty.

the class OcspTest method testClientRejectingOcspStaple.

/**
 * The Server provides an OCSP staple and the Client rejects it.
 */
private static void testClientRejectingOcspStaple(SslProvider sslProvider) throws Exception {
    final AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
    final CountDownLatch latch = new CountDownLatch(1);
    ChannelInboundHandlerAdapter clientHandler = new ChannelInboundHandlerAdapter() {

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            try {
                causeRef.set(cause);
            } finally {
                latch.countDown();
            }
        }
    };
    byte[] response = newOcspResponse();
    TestClientOcspContext callback = new TestClientOcspContext(false);
    handshake(sslProvider, latch, null, response, clientHandler, callback);
    byte[] actual = callback.response();
    assertNotNull(actual);
    assertNotSame(response, actual);
    assertArrayEquals(response, actual);
    Throwable cause = causeRef.get();
    assertThat(cause, CoreMatchers.instanceOf(SSLHandshakeException.class));
}

Example 43 with ChannelInboundHandlerAdapter

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInboundHandlerAdapter in project netty by netty.

the class SSLEngineTest method mySetupClientHostnameValidation.

private Future<Void> mySetupClientHostnameValidation(final SSLEngineTestParam param, File serverCrtFile, File serverKeyFile, File clientTrustCrtFile, final boolean failureExpected) throws SSLException, InterruptedException {
    final String expectedHost = "localhost";
    serverSslCtx = wrapContext(param, SslContextBuilder.forServer(serverCrtFile, serverKeyFile, null).sslProvider(sslServerProvider()).protocols(param.protocols()).ciphers(param.ciphers()).sslContextProvider(serverSslContextProvider()).trustManager(InsecureTrustManagerFactory.INSTANCE).ciphers(null, IdentityCipherSuiteFilter.INSTANCE).sessionCacheSize(0).sessionTimeout(0).build());
    clientSslCtx = wrapContext(param, SslContextBuilder.forClient().sslProvider(sslClientProvider()).protocols(param.protocols()).ciphers(param.ciphers()).sslContextProvider(clientSslContextProvider()).trustManager(clientTrustCrtFile).ciphers(null, IdentityCipherSuiteFilter.INSTANCE).sessionCacheSize(0).sessionTimeout(0).build());
    serverConnectedChannel = null;
    sb = new ServerBootstrap();
    cb = new Bootstrap();
    sb.group(new NioEventLoopGroup(), new NioEventLoopGroup());
    sb.channel(NioServerSocketChannel.class);
    sb.childHandler(new ChannelInitializer<Channel>() {

        @Override
        protected void initChannel(Channel ch) throws Exception {
            ch.config().setAllocator(new TestByteBufAllocator(ch.config().getAllocator(), param.type));
            ChannelPipeline p = ch.pipeline();
            SslHandler handler = !param.delegate ? serverSslCtx.newHandler(ch.alloc()) : serverSslCtx.newHandler(ch.alloc(), delegatingExecutor);
            p.addLast(handler);
            p.addLast(new MessageDelegatorChannelHandler(serverReceiver, serverLatch));
            p.addLast(new ChannelInboundHandlerAdapter() {

                @Override
                public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
                    if (evt == SslHandshakeCompletionEvent.SUCCESS) {
                        if (failureExpected) {
                            serverException = new IllegalStateException("handshake complete. expected failure");
                        }
                        serverLatch.countDown();
                    } else if (evt instanceof SslHandshakeCompletionEvent) {
                        serverException = ((SslHandshakeCompletionEvent) evt).cause();
                        serverLatch.countDown();
                    }
                    ctx.fireUserEventTriggered(evt);
                }

                @Override
                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                    if (cause.getCause() instanceof SSLHandshakeException) {
                        serverException = cause.getCause();
                        serverLatch.countDown();
                    } else {
                        serverException = cause;
                        ctx.fireExceptionCaught(cause);
                    }
                }
            });
            serverConnectedChannel = ch;
        }
    });
    final Promise<Void> clientWritePromise = ImmediateEventExecutor.INSTANCE.newPromise();
    cb.group(new NioEventLoopGroup());
    cb.channel(NioSocketChannel.class);
    cb.handler(new ChannelInitializer<Channel>() {

        @Override
        protected void initChannel(Channel ch) throws Exception {
            ch.config().setAllocator(new TestByteBufAllocator(ch.config().getAllocator(), param.type));
            ChannelPipeline p = ch.pipeline();
            InetSocketAddress remoteAddress = (InetSocketAddress) serverChannel.localAddress();
            SslHandler sslHandler = !param.delegate ? clientSslCtx.newHandler(ch.alloc(), expectedHost, 0) : clientSslCtx.newHandler(ch.alloc(), expectedHost, 0, delegatingExecutor);
            SSLParameters parameters = sslHandler.engine().getSSLParameters();
            if (SslUtils.isValidHostNameForSNI(expectedHost)) {
                assertEquals(1, parameters.getServerNames().size());
                assertEquals(new SNIHostName(expectedHost), parameters.getServerNames().get(0));
            }
            parameters.setEndpointIdentificationAlgorithm("HTTPS");
            sslHandler.engine().setSSLParameters(parameters);
            p.addLast(sslHandler);
            p.addLast(new MessageDelegatorChannelHandler(clientReceiver, clientLatch));
            p.addLast(new ChannelInboundHandlerAdapter() {

                @Override
                public void handlerAdded(ChannelHandlerContext ctx) {
                    // about verifying the payload and releasing the content on the server side.
                    if (failureExpected) {
                        ChannelFuture f = ctx.write(ctx.alloc().buffer(1).writeByte(1));
                        PromiseNotifier.cascade(f, clientWritePromise);
                    }
                }

                @Override
                public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
                    if (evt == SslHandshakeCompletionEvent.SUCCESS) {
                        if (failureExpected) {
                            clientException = new IllegalStateException("handshake complete. expected failure");
                        }
                        clientLatch.countDown();
                    } else if (evt instanceof SslHandshakeCompletionEvent) {
                        clientException = ((SslHandshakeCompletionEvent) evt).cause();
                        clientLatch.countDown();
                    }
                    ctx.fireUserEventTriggered(evt);
                }

                @Override
                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                    if (cause.getCause() instanceof SSLHandshakeException) {
                        clientException = cause.getCause();
                        clientLatch.countDown();
                    } else {
                        ctx.fireExceptionCaught(cause);
                    }
                }
            });
        }
    });
    serverChannel = sb.bind(new InetSocketAddress(expectedHost, 0)).sync().channel();
    final int port = ((InetSocketAddress) serverChannel.localAddress()).getPort();
    ChannelFuture ccf = cb.connect(new InetSocketAddress(expectedHost, port));
    assertTrue(ccf.awaitUninterruptibly().isSuccess());
    clientChannel = ccf.channel();
    return clientWritePromise;
}

Example 44 with ChannelInboundHandlerAdapter

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInboundHandlerAdapter in project netty by netty.

the class IdleStateHandlerTest method anyIdle.

private static void anyIdle(TestableIdleStateHandler idleStateHandler, Object... expected) throws Exception {
    assertThat(expected.length, greaterThanOrEqualTo(1));
    final List<Object> events = new ArrayList<Object>();
    ChannelInboundHandlerAdapter handler = new ChannelInboundHandlerAdapter() {

        @Override
        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
            events.add(evt);
        }
    };
    EmbeddedChannel channel = new EmbeddedChannel(idleStateHandler, handler);
    try {
        // or read anything from the channel.
        for (int i = 0; i < expected.length; i++) {
            idleStateHandler.tickRun();
        }
        assertEquals(expected.length, events.size());
        // Compare the expected with the actual IdleStateEvents
        for (int i = 0; i < expected.length; i++) {
            Object evt = events.get(i);
            assertSame(expected[i], evt, "Element " + i + " is not matching");
        }
    } finally {
        channel.finishAndReleaseAll();
    }
}

Example 45 with ChannelInboundHandlerAdapter

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInboundHandlerAdapter in project netty by netty.

the class IdleStateHandlerTest method anyNotIdle.

private static void anyNotIdle(TestableIdleStateHandler idleStateHandler, Action action, Object expected) throws Exception {
    final List<Object> events = new ArrayList<Object>();
    ChannelInboundHandlerAdapter handler = new ChannelInboundHandlerAdapter() {

        @Override
        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
            events.add(evt);
        }
    };
    EmbeddedChannel channel = new EmbeddedChannel(idleStateHandler, handler);
    try {
        idleStateHandler.tick(1L, TimeUnit.NANOSECONDS);
        action.run(channel);
        // Advance the ticker by some fraction and run() the task.
        // There shouldn't be an IdleStateEvent getting fired because
        // we've just performed an action on the channel that is meant
        // to reset the idle task.
        long delayInNanos = idleStateHandler.delay(TimeUnit.NANOSECONDS);
        assertNotEquals(0L, delayInNanos);
        idleStateHandler.tickRun(delayInNanos / 2L, TimeUnit.NANOSECONDS);
        assertEquals(0, events.size());
        // Advance the ticker by the full amount and it should yield
        // in an IdleStateEvent.
        idleStateHandler.tickRun();
        assertEquals(1, events.size());
        assertSame(expected, events.get(0));
    } finally {
        channel.finishAndReleaseAll();
    }
}