Search in sources :

Example 66 with HttpServerExchange

use of io.undertow.server.HttpServerExchange in project undertow by undertow-io.

the class AsyncReceiverImpl method receivePartialString.

@Override
public void receivePartialString(final PartialStringCallback callback, final ErrorCallback errorCallback, Charset charset) {
    if (done) {
        throw UndertowMessages.MESSAGES.requestBodyAlreadyRead();
    }
    final ErrorCallback error = errorCallback == null ? END_EXCHANGE : errorCallback;
    if (callback == null) {
        throw UndertowMessages.MESSAGES.argumentCannotBeNull("callback");
    }
    if (exchange.isRequestComplete()) {
        callback.handle(exchange, "", true);
        return;
    }
    String contentLengthString = exchange.getRequestHeaders().getFirst(Headers.CONTENT_LENGTH);
    long contentLength;
    if (contentLengthString != null) {
        contentLength = Long.parseLong(contentLengthString);
        if (contentLength > Integer.MAX_VALUE) {
            error.error(exchange, new RequestToLargeException());
            return;
        }
    } else {
        contentLength = -1;
    }
    if (maxBufferSize > 0) {
        if (contentLength > maxBufferSize) {
            error.error(exchange, new RequestToLargeException());
            return;
        }
    }
    final CharsetDecoder decoder = charset.newDecoder();
    PooledByteBuffer pooled = exchange.getConnection().getByteBufferPool().allocate();
    final ByteBuffer buffer = pooled.getBuffer();
    channel.getReadSetter().set(new ChannelListener<StreamSourceChannel>() {

        @Override
        public void handleEvent(final StreamSourceChannel channel) {
            if (done || paused) {
                return;
            }
            PooledByteBuffer pooled = exchange.getConnection().getByteBufferPool().allocate();
            final ByteBuffer buffer = pooled.getBuffer();
            try {
                int res;
                do {
                    if (paused) {
                        return;
                    }
                    try {
                        buffer.clear();
                        res = channel.read(buffer);
                        if (res == -1) {
                            done = true;
                            Connectors.executeRootHandler(new HttpHandler() {

                                @Override
                                public void handleRequest(HttpServerExchange exchange) throws Exception {
                                    callback.handle(exchange, "", true);
                                }
                            }, exchange);
                            return;
                        } else if (res == 0) {
                            return;
                        } else {
                            buffer.flip();
                            final CharBuffer cb = decoder.decode(buffer);
                            Connectors.executeRootHandler(new HttpHandler() {

                                @Override
                                public void handleRequest(HttpServerExchange exchange) throws Exception {
                                    callback.handle(exchange, cb.toString(), false);
                                    if (!paused) {
                                        channel.resumeReads();
                                    } else {
                                        System.out.println("paused");
                                    }
                                }
                            }, exchange);
                        }
                    } catch (final IOException e) {
                        Connectors.executeRootHandler(new HttpHandler() {

                            @Override
                            public void handleRequest(HttpServerExchange exchange) throws Exception {
                                error.error(exchange, e);
                            }
                        }, exchange);
                        return;
                    }
                } while (true);
            } finally {
                pooled.close();
            }
        }
    });
    try {
        int res;
        do {
            try {
                buffer.clear();
                res = channel.read(buffer);
                if (res == -1) {
                    done = true;
                    callback.handle(exchange, "", true);
                    return;
                } else if (res == 0) {
                    channel.resumeReads();
                    return;
                } else {
                    buffer.flip();
                    CharBuffer cb = decoder.decode(buffer);
                    callback.handle(exchange, cb.toString(), false);
                    if (paused) {
                        return;
                    }
                }
            } catch (IOException e) {
                error.error(exchange, e);
                return;
            }
        } while (true);
    } finally {
        pooled.close();
    }
}
Also used : StreamSourceChannel(org.xnio.channels.StreamSourceChannel) HttpHandler(io.undertow.server.HttpHandler) CharsetDecoder(java.nio.charset.CharsetDecoder) CharBuffer(java.nio.CharBuffer) IOException(java.io.IOException) ByteBuffer(java.nio.ByteBuffer) PooledByteBuffer(io.undertow.connector.PooledByteBuffer) IOException(java.io.IOException) HttpServerExchange(io.undertow.server.HttpServerExchange) PooledByteBuffer(io.undertow.connector.PooledByteBuffer)

Example 67 with HttpServerExchange

use of io.undertow.server.HttpServerExchange in project undertow by undertow-io.

the class AsyncReceiverImpl method receiveFullString.

@Override
public void receiveFullString(final FullStringCallback callback, final ErrorCallback errorCallback, final Charset charset) {
    if (done) {
        throw UndertowMessages.MESSAGES.requestBodyAlreadyRead();
    }
    final ErrorCallback error = errorCallback == null ? END_EXCHANGE : errorCallback;
    if (callback == null) {
        throw UndertowMessages.MESSAGES.argumentCannotBeNull("callback");
    }
    if (exchange.isRequestComplete()) {
        callback.handle(exchange, "");
        return;
    }
    String contentLengthString = exchange.getRequestHeaders().getFirst(Headers.CONTENT_LENGTH);
    long contentLength;
    final ByteArrayOutputStream sb;
    if (contentLengthString != null) {
        contentLength = Long.parseLong(contentLengthString);
        if (contentLength > Integer.MAX_VALUE) {
            error.error(exchange, new RequestToLargeException());
            return;
        }
        sb = new ByteArrayOutputStream((int) contentLength);
    } else {
        contentLength = -1;
        sb = new ByteArrayOutputStream();
    }
    if (maxBufferSize > 0) {
        if (contentLength > maxBufferSize) {
            error.error(exchange, new RequestToLargeException());
            return;
        }
    }
    PooledByteBuffer pooled = exchange.getConnection().getByteBufferPool().allocate();
    final ByteBuffer buffer = pooled.getBuffer();
    try {
        int res;
        do {
            try {
                buffer.clear();
                res = channel.read(buffer);
                if (res == -1) {
                    done = true;
                    callback.handle(exchange, sb.toString(charset.name()));
                    return;
                } else if (res == 0) {
                    channel.getReadSetter().set(new ChannelListener<StreamSourceChannel>() {

                        @Override
                        public void handleEvent(StreamSourceChannel channel) {
                            if (done) {
                                return;
                            }
                            PooledByteBuffer pooled = exchange.getConnection().getByteBufferPool().allocate();
                            final ByteBuffer buffer = pooled.getBuffer();
                            try {
                                int res;
                                do {
                                    try {
                                        buffer.clear();
                                        res = channel.read(buffer);
                                        if (res == -1) {
                                            done = true;
                                            Connectors.executeRootHandler(new HttpHandler() {

                                                @Override
                                                public void handleRequest(HttpServerExchange exchange) throws Exception {
                                                    callback.handle(exchange, sb.toString(charset.name()));
                                                }
                                            }, exchange);
                                            return;
                                        } else if (res == 0) {
                                            return;
                                        } else {
                                            buffer.flip();
                                            while (buffer.hasRemaining()) {
                                                sb.write(buffer.get());
                                            }
                                            if (maxBufferSize > 0 && sb.size() > maxBufferSize) {
                                                Connectors.executeRootHandler(new HttpHandler() {

                                                    @Override
                                                    public void handleRequest(HttpServerExchange exchange) throws Exception {
                                                        error.error(exchange, new RequestToLargeException());
                                                    }
                                                }, exchange);
                                                return;
                                            }
                                        }
                                    } catch (final IOException e) {
                                        Connectors.executeRootHandler(new HttpHandler() {

                                            @Override
                                            public void handleRequest(HttpServerExchange exchange) throws Exception {
                                                error.error(exchange, e);
                                            }
                                        }, exchange);
                                        return;
                                    }
                                } while (true);
                            } finally {
                                pooled.close();
                            }
                        }
                    });
                    channel.resumeReads();
                    return;
                } else {
                    buffer.flip();
                    while (buffer.hasRemaining()) {
                        sb.write(buffer.get());
                    }
                    if (maxBufferSize > 0 && sb.size() > maxBufferSize) {
                        error.error(exchange, new RequestToLargeException());
                        return;
                    }
                }
            } catch (IOException e) {
                error.error(exchange, e);
                return;
            }
        } while (true);
    } finally {
        pooled.close();
    }
}
Also used : StreamSourceChannel(org.xnio.channels.StreamSourceChannel) HttpHandler(io.undertow.server.HttpHandler) ChannelListener(org.xnio.ChannelListener) ByteArrayOutputStream(java.io.ByteArrayOutputStream) IOException(java.io.IOException) ByteBuffer(java.nio.ByteBuffer) PooledByteBuffer(io.undertow.connector.PooledByteBuffer) IOException(java.io.IOException) HttpServerExchange(io.undertow.server.HttpServerExchange) PooledByteBuffer(io.undertow.connector.PooledByteBuffer)

Example 68 with HttpServerExchange

use of io.undertow.server.HttpServerExchange in project undertow by undertow-io.

the class AsyncReceiverImpl method receiveFullBytes.

@Override
public void receiveFullBytes(final FullBytesCallback callback, final ErrorCallback errorCallback) {
    if (done) {
        throw UndertowMessages.MESSAGES.requestBodyAlreadyRead();
    }
    final ErrorCallback error = errorCallback == null ? END_EXCHANGE : errorCallback;
    if (callback == null) {
        throw UndertowMessages.MESSAGES.argumentCannotBeNull("callback");
    }
    if (exchange.isRequestComplete()) {
        callback.handle(exchange, EMPTY_BYTE_ARRAY);
        return;
    }
    String contentLengthString = exchange.getRequestHeaders().getFirst(Headers.CONTENT_LENGTH);
    long contentLength;
    final ByteArrayOutputStream sb;
    if (contentLengthString != null) {
        contentLength = Long.parseLong(contentLengthString);
        if (contentLength > Integer.MAX_VALUE) {
            error.error(exchange, new RequestToLargeException());
            return;
        }
        sb = new ByteArrayOutputStream((int) contentLength);
    } else {
        contentLength = -1;
        sb = new ByteArrayOutputStream();
    }
    if (maxBufferSize > 0) {
        if (contentLength > maxBufferSize) {
            error.error(exchange, new RequestToLargeException());
            return;
        }
    }
    PooledByteBuffer pooled = exchange.getConnection().getByteBufferPool().allocate();
    final ByteBuffer buffer = pooled.getBuffer();
    try {
        int res;
        do {
            try {
                buffer.clear();
                res = channel.read(buffer);
                if (res == -1) {
                    done = true;
                    callback.handle(exchange, sb.toByteArray());
                    return;
                } else if (res == 0) {
                    channel.getReadSetter().set(new ChannelListener<StreamSourceChannel>() {

                        @Override
                        public void handleEvent(StreamSourceChannel channel) {
                            if (done) {
                                return;
                            }
                            PooledByteBuffer pooled = exchange.getConnection().getByteBufferPool().allocate();
                            final ByteBuffer buffer = pooled.getBuffer();
                            try {
                                int res;
                                do {
                                    try {
                                        buffer.clear();
                                        res = channel.read(buffer);
                                        if (res == -1) {
                                            done = true;
                                            Connectors.executeRootHandler(new HttpHandler() {

                                                @Override
                                                public void handleRequest(HttpServerExchange exchange) throws Exception {
                                                    callback.handle(exchange, sb.toByteArray());
                                                }
                                            }, exchange);
                                            return;
                                        } else if (res == 0) {
                                            return;
                                        } else {
                                            buffer.flip();
                                            while (buffer.hasRemaining()) {
                                                sb.write(buffer.get());
                                            }
                                            if (maxBufferSize > 0 && sb.size() > maxBufferSize) {
                                                Connectors.executeRootHandler(new HttpHandler() {

                                                    @Override
                                                    public void handleRequest(HttpServerExchange exchange) throws Exception {
                                                        error.error(exchange, new RequestToLargeException());
                                                    }
                                                }, exchange);
                                                return;
                                            }
                                        }
                                    } catch (final Exception e) {
                                        Connectors.executeRootHandler(new HttpHandler() {

                                            @Override
                                            public void handleRequest(HttpServerExchange exchange) throws Exception {
                                                error.error(exchange, new IOException(e));
                                            }
                                        }, exchange);
                                        return;
                                    }
                                } while (true);
                            } finally {
                                pooled.close();
                            }
                        }
                    });
                    channel.resumeReads();
                    return;
                } else {
                    buffer.flip();
                    while (buffer.hasRemaining()) {
                        sb.write(buffer.get());
                    }
                    if (maxBufferSize > 0 && sb.size() > maxBufferSize) {
                        error.error(exchange, new RequestToLargeException());
                        return;
                    }
                }
            } catch (IOException e) {
                error.error(exchange, e);
                return;
            }
        } while (true);
    } finally {
        pooled.close();
    }
}
Also used : StreamSourceChannel(org.xnio.channels.StreamSourceChannel) HttpHandler(io.undertow.server.HttpHandler) ChannelListener(org.xnio.ChannelListener) ByteArrayOutputStream(java.io.ByteArrayOutputStream) IOException(java.io.IOException) ByteBuffer(java.nio.ByteBuffer) PooledByteBuffer(io.undertow.connector.PooledByteBuffer) IOException(java.io.IOException) HttpServerExchange(io.undertow.server.HttpServerExchange) PooledByteBuffer(io.undertow.connector.PooledByteBuffer)

Example 69 with HttpServerExchange

use of io.undertow.server.HttpServerExchange in project undertow by undertow-io.

the class AsyncReceiverImpl method receivePartialBytes.

@Override
public void receivePartialBytes(final PartialBytesCallback callback, final ErrorCallback errorCallback) {
    if (done) {
        throw UndertowMessages.MESSAGES.requestBodyAlreadyRead();
    }
    final ErrorCallback error = errorCallback == null ? END_EXCHANGE : errorCallback;
    if (callback == null) {
        throw UndertowMessages.MESSAGES.argumentCannotBeNull("callback");
    }
    if (exchange.isRequestComplete()) {
        callback.handle(exchange, EMPTY_BYTE_ARRAY, true);
        return;
    }
    String contentLengthString = exchange.getRequestHeaders().getFirst(Headers.CONTENT_LENGTH);
    long contentLength;
    if (contentLengthString != null) {
        contentLength = Long.parseLong(contentLengthString);
        if (contentLength > Integer.MAX_VALUE) {
            error.error(exchange, new RequestToLargeException());
            return;
        }
    } else {
        contentLength = -1;
    }
    if (maxBufferSize > 0) {
        if (contentLength > maxBufferSize) {
            error.error(exchange, new RequestToLargeException());
            return;
        }
    }
    PooledByteBuffer pooled = exchange.getConnection().getByteBufferPool().allocate();
    final ByteBuffer buffer = pooled.getBuffer();
    channel.getReadSetter().set(new ChannelListener<StreamSourceChannel>() {

        @Override
        public void handleEvent(final StreamSourceChannel channel) {
            if (done || paused) {
                return;
            }
            PooledByteBuffer pooled = exchange.getConnection().getByteBufferPool().allocate();
            final ByteBuffer buffer = pooled.getBuffer();
            try {
                int res;
                do {
                    if (paused) {
                        return;
                    }
                    try {
                        buffer.clear();
                        res = channel.read(buffer);
                        if (res == -1) {
                            done = true;
                            Connectors.executeRootHandler(new HttpHandler() {

                                @Override
                                public void handleRequest(HttpServerExchange exchange) throws Exception {
                                    callback.handle(exchange, EMPTY_BYTE_ARRAY, true);
                                }
                            }, exchange);
                            return;
                        } else if (res == 0) {
                            return;
                        } else {
                            buffer.flip();
                            final byte[] data = new byte[buffer.remaining()];
                            buffer.get(data);
                            Connectors.executeRootHandler(new HttpHandler() {

                                @Override
                                public void handleRequest(HttpServerExchange exchange) throws Exception {
                                    callback.handle(exchange, data, false);
                                    if (!paused) {
                                        channel.resumeReads();
                                    }
                                }
                            }, exchange);
                        }
                    } catch (final IOException e) {
                        Connectors.executeRootHandler(new HttpHandler() {

                            @Override
                            public void handleRequest(HttpServerExchange exchange) throws Exception {
                                error.error(exchange, e);
                            }
                        }, exchange);
                        return;
                    }
                } while (true);
            } finally {
                pooled.close();
            }
        }
    });
    try {
        int res;
        do {
            try {
                buffer.clear();
                res = channel.read(buffer);
                if (res == -1) {
                    done = true;
                    callback.handle(exchange, EMPTY_BYTE_ARRAY, true);
                    return;
                } else if (res == 0) {
                    channel.resumeReads();
                    return;
                } else {
                    buffer.flip();
                    byte[] data = new byte[buffer.remaining()];
                    buffer.get(data);
                    callback.handle(exchange, data, false);
                    if (paused) {
                        return;
                    }
                }
            } catch (IOException e) {
                error.error(exchange, e);
                return;
            }
        } while (true);
    } finally {
        pooled.close();
    }
}
Also used : StreamSourceChannel(org.xnio.channels.StreamSourceChannel) HttpHandler(io.undertow.server.HttpHandler) IOException(java.io.IOException) ByteBuffer(java.nio.ByteBuffer) PooledByteBuffer(io.undertow.connector.PooledByteBuffer) IOException(java.io.IOException) HttpServerExchange(io.undertow.server.HttpServerExchange) PooledByteBuffer(io.undertow.connector.PooledByteBuffer)

Example 70 with HttpServerExchange

use of io.undertow.server.HttpServerExchange in project undertow by undertow-io.

the class ComplexSSLTestCase method testSslLotsOfData.

@Test
// FIXME UNDERTOW-1918
@Ignore
public void testSslLotsOfData() throws IOException, GeneralSecurityException, URISyntaxException {
    DefaultServer.setRootHandler(new HttpHandler() {

        @Override
        public void handleRequest(HttpServerExchange exchange) throws Exception {
            if (exchange.isInIoThread()) {
                exchange.dispatch(this);
                return;
            }
            exchange.startBlocking();
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            byte[] buf = new byte[100];
            int res = 0;
            while ((res = exchange.getInputStream().read(buf)) > 0) {
                out.write(buf, 0, res);
            }
            System.out.println("WRITE " + out.size());
            exchange.getOutputStream().write(out.toByteArray());
            System.out.println("DONE " + out.size());
        }
    });
    DefaultServer.startSSLServer();
    TestHttpClient client = new TestHttpClient();
    client.setSSLContext(DefaultServer.getClientSSLContext());
    try {
        generateMessage(1000000);
        HttpPost post = new HttpPost(DefaultServer.getDefaultServerSSLAddress());
        post.setEntity(new StringEntity(message));
        HttpResponse resultList = client.execute(post);
        Assert.assertEquals(StatusCodes.OK, resultList.getStatusLine().getStatusCode());
        String response = HttpClientUtils.readResponse(resultList);
        Assert.assertEquals(message.length(), response.length());
        Assert.assertEquals(message, response);
        generateMessage(100000);
        post = new HttpPost(DefaultServer.getDefaultServerSSLAddress());
        post.setEntity(new StringEntity(message));
        resultList = client.execute(post);
        Assert.assertEquals(StatusCodes.OK, resultList.getStatusLine().getStatusCode());
        response = HttpClientUtils.readResponse(resultList);
        Assert.assertEquals(message.length(), response.length());
        Assert.assertEquals(message, response);
    } finally {
        client.getConnectionManager().shutdown();
        DefaultServer.stopSSLServer();
    }
}
Also used : HttpServerExchange(io.undertow.server.HttpServerExchange) HttpHandler(io.undertow.server.HttpHandler) HttpPost(org.apache.http.client.methods.HttpPost) StringEntity(org.apache.http.entity.StringEntity) HttpResponse(org.apache.http.HttpResponse) ByteArrayOutputStream(java.io.ByteArrayOutputStream) URISyntaxException(java.net.URISyntaxException) GeneralSecurityException(java.security.GeneralSecurityException) IOException(java.io.IOException) TestHttpClient(io.undertow.testutils.TestHttpClient) Ignore(org.junit.Ignore) AjpIgnore(io.undertow.testutils.AjpIgnore) Test(org.junit.Test)

Aggregations

HttpServerExchange (io.undertow.server.HttpServerExchange)277 HttpHandler (io.undertow.server.HttpHandler)127 Test (org.junit.Test)109 IOException (java.io.IOException)90 UnitTest (io.undertow.testutils.category.UnitTest)45 BeforeClass (org.junit.BeforeClass)44 TestHttpClient (io.undertow.testutils.TestHttpClient)42 HttpGet (org.apache.http.client.methods.HttpGet)40 HttpResponse (org.apache.http.HttpResponse)37 HttpString (io.undertow.util.HttpString)36 Header (org.apache.http.Header)24 Undertow (io.undertow.Undertow)19 ByteBuffer (java.nio.ByteBuffer)19 SessionConfig (io.undertow.server.session.SessionConfig)16 Map (java.util.Map)16 Sender (io.undertow.io.Sender)15 ExchangeCompletionListener (io.undertow.server.ExchangeCompletionListener)14 HeaderMap (io.undertow.util.HeaderMap)13 URI (java.net.URI)13 HeaderValues (io.undertow.util.HeaderValues)12