Examples with StreamSourceChannel org.xnio.channels.StreamSourceChannel used on opensource projects

Example 11 with StreamSourceChannel

use of org.xnio.channels.StreamSourceChannel in project undertow by undertow-io.

the class HttpReadListener method handleHttp2PriorKnowledge.

private void handleHttp2PriorKnowledge(final StreamConnection connection, final HttpServerConnection serverConnection, PooledByteBuffer readData) throws IOException {
    final ConduitStreamSourceChannel request = connection.getSourceChannel();
    byte[] data = new byte[PRI_EXPECTED.length];
    final ByteBuffer buffer = ByteBuffer.wrap(data);
    if (readData.getBuffer().hasRemaining()) {
        while (readData.getBuffer().hasRemaining() && buffer.hasRemaining()) {
            buffer.put(readData.getBuffer().get());
        }
    }
    final PooledByteBuffer extraData;
    if (readData.getBuffer().hasRemaining()) {
        extraData = readData;
    } else {
        readData.close();
        extraData = null;
    }
    if (!doHttp2PriRead(connection, buffer, serverConnection, extraData)) {
        request.getReadSetter().set(new ChannelListener<StreamSourceChannel>() {

            @Override
            public void handleEvent(StreamSourceChannel channel) {
                try {
                    doHttp2PriRead(connection, buffer, serverConnection, extraData);
                } catch (IOException e) {
                    UndertowLogger.REQUEST_IO_LOGGER.ioException(e);
                    IoUtils.safeClose(connection);
                }
            }
        });
        request.resumeReads();
    }
}

Example 12 with StreamSourceChannel

use of org.xnio.channels.StreamSourceChannel in project undertow by undertow-io.

the class ALPNClientSelector method runAlpn.

public static void runAlpn(final SslConnection sslConnection, final ChannelListener<SslConnection> fallback, final ClientCallback<ClientConnection> failedListener, final ALPNProtocol... details) {
    SslConduit conduit = UndertowXnioSsl.getSslConduit(sslConnection);
    final ALPNProvider provider = ALPNManager.INSTANCE.getProvider(conduit.getSSLEngine());
    if (provider == null) {
        fallback.handleEvent(sslConnection);
        return;
    }
    String[] protocols = new String[details.length];
    final Map<String, ALPNProtocol> protocolMap = new HashMap<>();
    for (int i = 0; i < protocols.length; ++i) {
        protocols[i] = details[i].getProtocol();
        protocolMap.put(details[i].getProtocol(), details[i]);
    }
    final SSLEngine sslEngine = provider.setProtocols(conduit.getSSLEngine(), protocols);
    conduit.setSslEngine(sslEngine);
    final AtomicReference<Boolean> handshakeDone = new AtomicReference<>(false);
    try {
        sslConnection.startHandshake();
        sslConnection.getHandshakeSetter().set(new ChannelListener<SslConnection>() {

            @Override
            public void handleEvent(SslConnection channel) {
                if (handshakeDone.get()) {
                    return;
                }
                handshakeDone.set(true);
            }
        });
        sslConnection.getSourceChannel().getReadSetter().set(new ChannelListener<StreamSourceChannel>() {

            @Override
            public void handleEvent(StreamSourceChannel channel) {
                String selectedProtocol = provider.getSelectedProtocol(sslEngine);
                if (selectedProtocol != null) {
                    handleSelected(selectedProtocol);
                } else {
                    ByteBuffer buf = ByteBuffer.allocate(100);
                    try {
                        int read = channel.read(buf);
                        if (read > 0) {
                            buf.flip();
                            PushBackStreamSourceConduit pb = new PushBackStreamSourceConduit(sslConnection.getSourceChannel().getConduit());
                            pb.pushBack(new ImmediatePooled<>(buf));
                            sslConnection.getSourceChannel().setConduit(pb);
                        } else if (read == -1) {
                            failedListener.failed(new ClosedChannelException());
                        }
                        selectedProtocol = provider.getSelectedProtocol(sslEngine);
                        if (selectedProtocol != null) {
                            handleSelected(selectedProtocol);
                        } else if (read > 0 || handshakeDone.get()) {
                            sslConnection.getSourceChannel().suspendReads();
                            fallback.handleEvent(sslConnection);
                            return;
                        }
                    } catch (IOException e) {
                        failedListener.failed(e);
                    }
                }
            }

            private void handleSelected(String selected) {
                if (selected.isEmpty()) {
                    sslConnection.getSourceChannel().suspendReads();
                    fallback.handleEvent(sslConnection);
                    return;
                } else {
                    ALPNClientSelector.ALPNProtocol details = protocolMap.get(selected);
                    if (details == null) {
                        //should never happen
                        sslConnection.getSourceChannel().suspendReads();
                        fallback.handleEvent(sslConnection);
                        return;
                    } else {
                        sslConnection.getSourceChannel().suspendReads();
                        details.getSelected().handleEvent(sslConnection);
                    }
                }
            }
        });
        sslConnection.getSourceChannel().resumeReads();
    } catch (IOException e) {
        failedListener.failed(e);
    } catch (Throwable e) {
        failedListener.failed(new IOException(e));
    }
}

Example 13 with StreamSourceChannel

use of org.xnio.channels.StreamSourceChannel in project undertow by undertow-io.

the class ReadTimeoutTestCase method testReadTimeout.

@Test
public void testReadTimeout() throws IOException, InterruptedException {
    DefaultServer.setRootHandler(new HttpHandler() {

        @Override
        public void handleRequest(final HttpServerExchange exchange) throws Exception {
            final StreamSinkChannel response = exchange.getResponseChannel();
            final StreamSourceChannel request = exchange.getRequestChannel();
            try {
                request.setOption(Options.READ_TIMEOUT, 100);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            request.getReadSetter().set(ChannelListeners.drainListener(Long.MAX_VALUE, new ChannelListener<Channel>() {

                @Override
                public void handleEvent(final Channel channel) {
                    new StringWriteChannelListener("COMPLETED") {

                        @Override
                        protected void writeDone(final StreamSinkChannel channel) {
                            exchange.endExchange();
                        }
                    }.setup(response);
                }
            }, new ChannelExceptionHandler<StreamSourceChannel>() {

                @Override
                public void handleException(final StreamSourceChannel channel, final IOException e) {
                    exchange.endExchange();
                    exception = e;
                    errorLatch.countDown();
                }
            }));
            request.wakeupReads();
        }
    });
    final TestHttpClient client = new TestHttpClient();
    try {
        HttpPost post = new HttpPost(DefaultServer.getDefaultServerURL());
        post.setEntity(new AbstractHttpEntity() {

            @Override
            public InputStream getContent() throws IOException, IllegalStateException {
                return null;
            }

            @Override
            public void writeTo(final OutputStream outstream) throws IOException {
                for (int i = 0; i < 5; ++i) {
                    outstream.write('*');
                    outstream.flush();
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }

            @Override
            public boolean isStreaming() {
                return true;
            }

            @Override
            public boolean isRepeatable() {
                return false;
            }

            @Override
            public long getContentLength() {
                return 5;
            }
        });
        post.addHeader(Headers.CONNECTION_STRING, "close");
        try {
            client.execute(post);
        } catch (IOException e) {
        }
        if (errorLatch.await(5, TimeUnit.SECONDS)) {
            Assert.assertEquals(ReadTimeoutException.class, exception.getClass());
        } else {
            Assert.fail("Read did not time out");
        }
    } finally {
        client.getConnectionManager().shutdown();
    }
}