@Override public void exchangeEvent( final HttpServerExchange exchange, final ExchangeCompletionListener.NextListener nextListener) { connection.resetChannel(); final HttpServerConnection connection = this.connection; if (exchange.isPersistent() && !exchange.isUpgrade()) { newRequest(); StreamConnection channel = connection.getChannel(); if (connection.getExtraBytes() == null) { // if we are not pipelining we just register a listener channel.getSourceChannel().getReadSetter().set(this); channel.getSourceChannel().resumeReads(); } else { if (channel.getSourceChannel().isReadResumed()) { channel.getSourceChannel().suspendReads(); } if (exchange.isInIoThread()) { channel.getIoThread().execute(this); } else { Executor executor = exchange.getDispatchExecutor(); if (executor == null) { executor = exchange.getConnection().getWorker(); } executor.execute(this); } } } nextListener.proceed(); }
HttpReadListener(final HttpServerConnection connection, final HttpRequestParser parser) { this.connection = connection; this.parser = parser; maxRequestSize = connection .getUndertowOptions() .get(UndertowOptions.MAX_HEADER_SIZE, UndertowOptions.DEFAULT_MAX_HEADER_SIZE); this.maxEntitySize = connection.getUndertowOptions().get(UndertowOptions.MAX_ENTITY_SIZE, 0); }
private void sendExpect100(Map headers, RequestLine requestLine) throws TransformerException, IOException { // respond with status code 100, for Expect handshake // according to rfc 2616 and http 1.1 // the processing will continue and the request will be fully // read immediately after if (HttpConstants.HTTP11.equals(headers.get(HttpConnector.HTTP_VERSION_PROPERTY))) { // just in case we have something other than String in // the headers map String expectHeaderValue = ObjectUtils.toString(headers.get(HttpConstants.HEADER_EXPECT)).toLowerCase(); if (HttpConstants.HEADER_EXPECT_CONTINUE_REQUEST_VALUE.equals(expectHeaderValue)) { HttpResponse expected = new HttpResponse(); expected.setStatusLine(requestLine.getHttpVersion(), HttpConstants.SC_CONTINUE); final DefaultMuleEvent event = new DefaultMuleEvent( new DefaultMuleMessage(expected), endpoint, new DefaultMuleSession(service, connector.getMuleContext()), true); RequestContext.setEvent(event); conn.writeResponse(transformResponse(expected)); } } }
public void run() { long keepAliveTimeout = ((TcpConnector) connector).getKeepAliveTimeout(); try { do { conn.setKeepAlive(false); // Only add a monitor if the timeout has been set if (keepAliveTimeout > 0) { ((HttpConnector) connector) .getKeepAliveMonitor() .addExpirable(keepAliveTimeout, TimeUnit.MILLISECONDS, this); } HttpRequest request = conn.readRequest(); if (request == null) { break; } // Ensure that we drop any monitors, we'll add again for the next request ((HttpConnector) connector).getKeepAliveMonitor().removeExpirable(this); conn.writeResponse(processRequest(request)); if (request.getBody() != null) { request.getBody().close(); } } while (conn.isKeepAlive()); } catch (Exception e) { handleException(e); } finally { logger.debug("Closing HTTP connection."); if (conn.isOpen()) { conn.close(); conn = null; // Ensure that we drop any monitors ((HttpConnector) connector).getKeepAliveMonitor().removeExpirable(this); } } }
public void handleEvent(final StreamSourceChannel channel) { Pooled<ByteBuffer> existing = connection.getExtraBytes(); final Pooled<ByteBuffer> pooled = existing == null ? connection.getBufferPool().allocate() : existing; final ByteBuffer buffer = pooled.getResource(); boolean free = true; try { int res; do { if (existing == null) { buffer.clear(); try { res = channel.read(buffer); } catch (IOException e) { UndertowLogger.REQUEST_IO_LOGGER.debug("Error reading request", e); IoUtils.safeClose(connection); return; } } else { res = buffer.remaining(); } if (res == 0) { if (!channel.isReadResumed()) { channel.getReadSetter().set(this); channel.resumeReads(); } return; } else if (res == -1) { try { channel.suspendReads(); channel.shutdownReads(); final StreamSinkChannel responseChannel = this.connection.getChannel().getSinkChannel(); responseChannel.shutdownWrites(); // will return false if there's a response queued ahead of this one, so we'll set up a // listener then if (!responseChannel.flush()) { responseChannel .getWriteSetter() .set(ChannelListeners.flushingChannelListener(null, null)); responseChannel.resumeWrites(); } } catch (IOException e) { UndertowLogger.REQUEST_IO_LOGGER.debug("Error reading request", e); // f**k it, it's all ruined IoUtils.safeClose(channel); return; } return; } if (existing != null) { existing = null; connection.setExtraBytes(null); } else { buffer.flip(); } parser.handle(buffer, state, httpServerExchange); if (buffer.hasRemaining()) { free = false; connection.setExtraBytes(pooled); } int total = read + res; read = total; if (read > maxRequestSize) { UndertowLogger.REQUEST_LOGGER.requestHeaderWasTooLarge( connection.getPeerAddress(), maxRequestSize); IoUtils.safeClose(connection); return; } } while (!state.isComplete()); // we remove ourselves as the read listener from the channel; // if the http handler doesn't set any then reads will suspend, which is the right thing to do channel.getReadSetter().set(null); channel.suspendReads(); final HttpServerExchange httpServerExchange = this.httpServerExchange; httpServerExchange.putAttachment( UndertowOptions.ATTACHMENT_KEY, connection.getUndertowOptions()); httpServerExchange.setRequestScheme(connection.getSslSession() != null ? "https" : "http"); this.httpServerExchange = null; HttpTransferEncoding.setupRequest(httpServerExchange); HttpHandlers.executeRootHandler( connection.getRootHandler(), httpServerExchange, Thread.currentThread() instanceof XnioExecutor); } catch (Exception e) { sendBadRequestAndClose(connection.getChannel(), e); return; } finally { if (free) pooled.free(); } }
@Override public void run() { handleEvent(connection.getChannel().getSourceChannel()); }
public void release() { conn.close(); conn = null; }
public void expired() { if (conn.isOpen()) { conn.close(); } }