private void flushChannel(StreamSinkChannel stream) throws IOException { stream.shutdownWrites(); if (!stream.flush()) { stream.getWriteSetter().set(ChannelListeners.flushingChannelListener(null, writeExceptionHandler())); stream.resumeWrites(); } }
private void writeBufferBlocking(final boolean writeFinal) throws IOException { if (channel == null) { channel = exchange.getResponseChannel(); } buffer.flip(); while (buffer.hasRemaining()) { if(writeFinal) { channel.writeFinal(buffer); } else { channel.write(buffer); } if(buffer.hasRemaining()) { channel.awaitWritable(); } } buffer.clear(); state |= FLAG_WRITE_STARTED; }
private void writeFailed(final IOException e) { try { source.suspendReads(); sink.suspendWrites(); invokeChannelExceptionHandler(sink, writeExceptionHandler, e); } finally { pooledBuffer.free(); } }
@Override protected void writingComplete() { this.channel.getWriteSetter().set(null); this.channel.resumeWrites(); }
@Override public boolean send() throws IOException { if (!shutdown) { shutdown = true; responseChannel.shutdownWrites(); } return responseChannel.flush(); }
private long doWrite(ByteBuffer[] srcs, int offset, int length, final boolean writeFinal) throws IOException { if(writeFinal) { return delegate.writeFinal(srcs, offset, length); } return delegate.write(srcs, offset, length); }
private static void internalSendContinueResponse(final HttpServerExchange exchange, final IoCallback callback) { if(exchange.getAttachment(ALREADY_SENT) != null) { callback.onComplete(exchange, null); return; HttpServerExchange newExchange = exchange.getConnection().sendOutOfBandResponse(exchange); exchange.putAttachment(ALREADY_SENT, true); newExchange.setStatusCode(StatusCodes.CONTINUE); newExchange.getResponseHeaders().put(Headers.CONTENT_LENGTH, 0); final StreamSinkChannel responseChannel = newExchange.getResponseChannel(); try { responseChannel.shutdownWrites(); if (!responseChannel.flush()) { responseChannel.getWriteSetter().set(ChannelListeners.flushingChannelListener( new ChannelListener<StreamSinkChannel>() { @Override responseChannel.resumeWrites(); exchange.dispatch(); } else {
parseTimeoutUpdater.failedParse(); if (!channel.isReadResumed()) { channel.getReadSetter().set(this); responseChannel.shutdownWrites(); safeClose(connection); } catch (IOException e) { httpServerExchange = new HttpServerExchange(connection, maxEntitySize); UndertowLogger.REQUEST_LOGGER.debug("Received CPONG, starting next request"); state = new AjpRequestParseState(); channel.getReadSetter().set(this); channel.getReadSetter().set(null); Connectors.terminateResponse(httpServerExchange); }, httpServerExchange.getRequestMethod().equals(Methods.HEAD)); connection.getChannel().getSinkChannel().setConduit(responseConduit); connection.getChannel().getSourceChannel().setConduit(createSourceConduit(connection.getChannel().getSourceChannel().getConduit(), responseConduit, httpServerExchange)); httpServerExchange.setSourceAddress(state.createPeerAddress());
sink.suspendWrites(); } else { sink.wakeupWrites(); sink.suspendWrites(); invokeChannelExceptionHandler(source, readExceptionHandler, new EOFException()); final int res; try { res = sink.write(buffer); } catch (IOException e) { invokeChannelExceptionHandler(sink, writeExceptionHandler, e); return; source.getReadSetter().set(listener); sink.getWriteSetter().set(listener); sink.resumeWrites(); free = false; return; sink.suspendWrites(); } else { sink.wakeupWrites(); sink.suspendWrites(); sink.getWriteSetter().set(listener);
throw UndertowMessages.MESSAGES.argumentCannotBeNull("callback"); if(!exchange.getConnection().isOpen()) { invokeOnException(callback, new ClosedChannelException()); return; if(exchange.isResponseComplete()) { invokeOnException(callback, new IOException(UndertowMessages.MESSAGES.responseComplete())); throw UndertowMessages.MESSAGES.dataAlreadyQueued(); long responseContentLength = exchange.getResponseContentLength(); if(responseContentLength > 0 && buffer.remaining() > responseContentLength) { invokeOnException(callback, UndertowLogger.ROOT_LOGGER.dataLargerThanContentLength(buffer.remaining(), responseContentLength)); return; int res = channel.write(buffer); if (res == 0) { this.buffer = new ByteBuffer[]{buffer}; initWriteListener(); channel.getWriteSetter().set(writeListener); channel.resumeWrites(); return;
@Override public void handleRequest(final HttpServerExchange exchange) throws Exception { exchange.getResponseHeaders().put(Headers.CONTENT_TYPE, "text/event-stream; charset=UTF-8"); exchange.setPersistent(false); final StreamSinkChannel sink = exchange.getResponseChannel(); if(!sink.flush()) { sink.getWriteSetter().set(ChannelListeners.flushingChannelListener(new ChannelListener<StreamSinkChannel>() { @Override public void handleEvent(StreamSinkChannel channel) { handleConnect(channel, exchange); } }, new ChannelExceptionHandler<StreamSinkChannel>() { @Override public void handleException(StreamSinkChannel channel, IOException exception) { IoUtils.safeClose(exchange.getConnection()); } })); sink.resumeWrites(); } else { exchange.dispatch(exchange.getIoThread(), new Runnable() { @Override public void run() { handleConnect(sink, exchange); } }); } }
StreamSinkChannel channel = this.channel; if (channel == null) { if (exchange.getResponseContentLength() == -1 && !exchange.getResponseHeaders().contains(Headers.TRANSFER_ENCODING)) { exchange.setResponseContentLength(0); this.channel = channel = exchange.getResponseChannel(); channel.shutdownWrites(); if (!channel.flush()) { channel.getWriteSetter().set(ChannelListeners.flushingChannelListener( new ChannelListener<StreamSinkChannel>() { @Override channel.resumeWrites(); } else { if (callback != null) {
if (dest == null) { if (callback == IoCallback.END_EXCHANGE) { if (exchange.getResponseContentLength() == -1 && !exchange.getResponseHeaders().contains(Headers.TRANSFER_ENCODING)) { exchange.setResponseContentLength(size); long ret = dest.transferFrom(source, pos, size - pos); pos += ret; if (ret == 0) { source.position(pos); dest.getWriteSetter().set(this); dest.resumeWrites(); return false;
if (anyAreSet(state, FLAG_CLOSED)) return; try { state |= FLAG_CLOSED; if (anyAreClear(state, FLAG_WRITE_STARTED) && channel == null) { if (buffer == null) { exchange.getResponseHeaders().put(Headers.CONTENT_LENGTH, "0"); } else { exchange.getResponseHeaders().put(Headers.CONTENT_LENGTH, "" + buffer.position()); channel = exchange.getResponseChannel(); channel.shutdownWrites(); Channels.flushBlocking(channel); } finally {
if(exchange.getConnection().isPushSupported() && result.getConnection().isPushSupported()) { result.setPushHandler(new PushCallback() { @Override if(requiresContinueResponse) { try { if(!result.getRequestChannel().flush()) { result.getRequestChannel().getWriteSetter().set(ChannelListeners.flushingChannelListener(new ChannelListener<StreamSinkChannel>() { @Override public void handleEvent(StreamSinkChannel channel) { result.getRequestChannel().resumeWrites(); return; if(!exchange.isRequestComplete()) { Transfer.initiateTransfer(exchange.getRequestChannel(), result.getRequestChannel(), ChannelListeners.closingChannelListener(), trailerListener, handler, handler, exchange.getConnection().getByteBufferPool()); } else { trailerListener.handleEvent(result.getRequestChannel());
for(;;) { try { read = source.read(buffer); buffer.flip(); } catch (IOException e) { ChannelListeners.invokeChannelExceptionHandler(source, readExceptionHandler, e); return; final int res; try { res = sink.write(buffer); } catch (IOException e) { ChannelListeners.invokeChannelExceptionHandler(sink, writeExceptionHandler, e); return; sink.getWriteSetter().set(listener); source.getReadSetter().set(listener); source.resumeReads(); sink.resumeWrites();
@Override public long transferTo(long count, ByteBuffer throughBuffer, StreamSinkChannel target) throws IOException { PooledByteBuffer[] buffered = getAttachment(BUFFERED_REQUEST_DATA); if (buffered == null) { return super.transferTo(count, throughBuffer, target); final ByteBuffer buf = pooled.getBuffer(); if (buf.hasRemaining()) { int res = target.write(buf); removeAttachment(BUFFERED_REQUEST_DATA); if (copied == 0) { return super.transferTo(count, throughBuffer, target);
public void handleEvent(final Channel channel) { if(done) { if(channel instanceof StreamSinkChannel) { ((StreamSinkChannel) channel).suspendWrites(); } else if(channel instanceof StreamSourceChannel) { ((StreamSourceChannel)channel).suspendReads(); final int res; try { res = sink.write(buffer); } catch (IOException e) { pooledBuffer.close(); pooledBuffer = null; done = true; ChannelListeners.invokeChannelExceptionHandler(sink, writeExceptionHandler, e); return; read = source.read(buffer); buffer.flip(); } catch (IOException e) { sink.suspendWrites(); } else if(!sink.isWriteResumed()) { sink.resumeWrites(); source.suspendReads(); } else if(!source.isReadResumed()){ source.resumeReads();
@Override public void handleEvent(StreamSinkChannel channel) { channel.suspendWrites(); channel.getWriteSetter().set(null); exchange.dispatch(this); }
public void handleEvent(final Channel channel) { final ByteBuffer buffer = pooledBuffer.getResource(); int state = this.state; lres = source.transferTo(count, buffer, sink); } catch (IOException e) { readFailed(e); ires = sink.write(buffer); } catch (IOException e) { writeFailed(e); this.count = count; this.state = 1; source.suspendReads(); sink.resumeWrites(); return; while (buffer.hasRemaining()) { try { ires = sink.write(buffer); } catch (IOException e) { writeFailed(e); this.count = count; this.state = 0; sink.suspendWrites(); source.resumeReads(); return;