@Override protected void writingComplete() { this.channel.getWriteSetter().set(null); this.channel.resumeWrites(); }
public void setWriteReadyHandler(final WriteReadyHandler handler) { channel.getWriteSetter().set(new ChannelListener<StreamSinkChannel>() { public void handleEvent(final StreamSinkChannel channel) { handler.writeReady(); } }); }
/** * Construct a new instance. * * @param delegate the delegate channel * @param delegateConfig {@code true} to delegate configuration, {@code false} otherwise */ public SplitStreamSinkChannel(final StreamSinkChannel delegate, boolean delegateConfig) { this.delegate = delegate; state = delegateConfig ? FLAG_DELEGATE_CONFIG : 0; delegate.getWriteSetter().set(new ChannelListener<StreamSinkChannel>() { public void handleEvent(final StreamSinkChannel channel) { invokeChannelListener(SplitStreamSinkChannel.this, writeListener); } }); }
public ResponseBodyProcessor(StreamSinkChannel channel) { super(request.getLogPrefix()); Assert.notNull(channel, "StreamSinkChannel must not be null"); this.channel = channel; this.channel.getWriteSetter().set(c -> { this.writePossible = true; onWritePossible(); }); this.channel.suspendWrites(); }
@Override protected void writingComplete() { this.channel.getWriteSetter().set(null); this.channel.resumeWrites(); }
@Override public void handleEvent(StreamSinkChannel channel) { channel.suspendWrites(); channel.getWriteSetter().set(null); } }, ChannelListeners.closingChannelExceptionHandler()));
public ResponseBodyProcessor(StreamSinkChannel channel) { super(request.getLogPrefix()); Assert.notNull(channel, "StreamSinkChannel must not be null"); this.channel = channel; this.channel.getWriteSetter().set(c -> { this.writePossible = true; onWritePossible(); }); this.channel.suspendWrites(); }
@Override public void handleEvent(StreamSinkChannel channel) { channel.suspendWrites(); channel.getWriteSetter().set(null); exchange.dispatch(this); }
private void runWriteTask() { Assert.assertHoldsLock(lock); if (pooledBuffer != null) { pooledBuffer.getBuffer().flip(); } state |= FLAG_WRITING; channel.getWriteSetter().set(channelListener); channel.wakeupWrites(); }
public void setup(final StreamSinkChannel channel) { try { int c; do { c = channel.write(buffer); } while (buffer.hasRemaining() && c > 0); if (buffer.hasRemaining()) { channel.getWriteSetter().set(this); channel.resumeWrites(); } else { writeDone(channel); } } catch (IOException e) { handleError(channel, e); } }
public ServerSentEventConnection(HttpServerExchange exchange, StreamSinkChannel sink) { this.exchange = exchange; this.sink = sink; this.sink.getCloseSetter().set(new ChannelListener<StreamSinkChannel>() { @Override public void handleEvent(StreamSinkChannel channel) { if(timerKey != null) { timerKey.remove(); } for (ChannelListener<ServerSentEventConnection> listener : closeTasks) { ChannelListeners.invokeChannelListener(ServerSentEventConnection.this, listener); } IoUtils.safeClose(ServerSentEventConnection.this); } }); this.sink.getWriteSetter().set(writeListener); }
@Override public void handleEvent(final StreamSinkChannel channel) { channel.suspendWrites(); channel.getWriteSetter().set(null); //defensive programming, should never happen if (anyAreClear(state, FLAG_RESPONSE_TERMINATED)) { UndertowLogger.ROOT_LOGGER.responseWasNotTerminated(connection, HttpServerExchange.this); IoUtils.safeClose(connection); } } }, new ChannelExceptionHandler<Channel>() {
private void flushChannel(StreamSinkChannel stream) throws IOException { stream.shutdownWrites(); if (!stream.flush()) { stream.getWriteSetter().set(ChannelListeners.flushingChannelListener(null, writeExceptionHandler())); stream.resumeWrites(); } }
@Override public ChannelListener.Setter<? extends StreamSinkChannel> getWriteSetter() { if (writeSetter == null) { writeSetter = new ChannelListener.SimpleSetter<>(); if (!isFinished()) { if(delegate instanceof ConduitStreamSinkChannel) { ((ConduitStreamSinkChannel) delegate).setWriteListener(new SetterDelegatingListener((ChannelListener.SimpleSetter)writeSetter, this)); } else { delegate.getWriteSetter().set(new SetterDelegatingListener((ChannelListener.SimpleSetter)writeSetter, this)); } } } return writeSetter; }
result.getRequestChannel().getWriteSetter() .set(ChannelListeners.<StreamSinkChannel>flushingChannelListener(null, null)); result.getRequestChannel().resumeWrites();
public void responseDone() { if(delegate instanceof ConduitStreamSinkChannel) { ((ConduitStreamSinkChannel) delegate).setCloseListener(null); ((ConduitStreamSinkChannel) delegate).setWriteListener(null); } else { delegate.getCloseSetter().set(null); delegate.getWriteSetter().set(null); } if (delegate.isWriteResumed()) { delegate.suspendWrites(); } }
protected void writeDone(final StreamSinkChannel channel) { try { channel.shutdownWrites(); if (!channel.flush()) { channel.getWriteSetter().set(ChannelListeners.flushingChannelListener(new ChannelListener<StreamSinkChannel>() { @Override public void handleEvent(StreamSinkChannel o) { IoUtils.safeClose(channel); } }, ChannelListeners.closingChannelExceptionHandler())); channel.resumeWrites(); } } catch (IOException e) { handleError(channel, e); } } }
/** * Construct a new instance. * * @param closeable the single central closeable channel * @param source the stream source channel * @param sink the stream sink channel */ public AssembledStreamChannel(final CloseableChannel closeable, final StreamSourceChannel source, final StreamSinkChannel sink) { if (source.getWorker() != sink.getWorker() || source.getWorker() != closeable.getWorker()) { throw msg.differentWorkers(); } this.closeable = closeable; this.source = source; this.sink = sink; readSetter = ChannelListeners.getDelegatingSetter(source.getReadSetter(), this); writeSetter = ChannelListeners.getDelegatingSetter(sink.getWriteSetter(), this); closeSetter = ChannelListeners.getDelegatingSetter(closeable.getCloseSetter(), this); }
@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); } }); } }
@Override public void completed(final ClientExchange result) { if (exchangeListener.isDone()) { IoUtils.safeClose(proxyConnection.getConnection()); return; } exchangeListener.exchange = result; result.setResponseListener(exchangeListener); try { result.getRequestChannel().shutdownWrites(); if (!result.getRequestChannel().flush()) { result.getRequestChannel().getWriteSetter().set(ChannelListeners.flushingChannelListener(null, new ChannelExceptionHandler<StreamSinkChannel>() { @Override public void handleException(StreamSinkChannel channel, IOException exception) { IoUtils.safeClose(proxyConnection.getConnection()); exchangeListener.taskFailed(); } })); result.getRequestChannel().resumeWrites(); } } catch (IOException e) { IoUtils.safeClose(proxyConnection.getConnection()); exchangeListener.taskFailed(); } }