/** * @return the close and compress flags as integer * @see #FLAG_CLOSE */ public byte getFlags() { return isClose() ? FLAG_CLOSE : 0; }
@Override public String toString() { return String.format("DATA @%x available=%d consumed=%d close=%b", hashCode(), available(), consumed(), isClose()); } }
@Override public void onData(Stream stream, DataInfo dataInfo) { logger.debug("Received {} on {}", dataInfo, stream); ServerHTTPSPDYAsyncConnection connection = (ServerHTTPSPDYAsyncConnection)stream.getAttribute(CONNECTION_ATTRIBUTE); connection.content(dataInfo, dataInfo.isClose()); if (dataInfo.isClose()) connection.endRequest(); } }
@Override public void data(DataInfo dataInfo, final Callback handler) { // Data buffer must be copied, as the ByteBuffer is pooled ByteBuffer byteBuffer = dataInfo.asByteBuffer(false); send(null, byteBuffer, dataInfo.isClose(), new Adapter() { @Override public void failed(Throwable x) { handler.failed(x); } }); if (dataInfo.isClose()) completed(); handler.succeeded(); } }
private void data(final Stream stream, final DataInfo serverDataInfo) { final ByteBufferDataInfo clientDataInfo = new ByteBufferDataInfo(serverDataInfo.asByteBuffer(false), serverDataInfo.isClose()) { @Override public void consume(int delta) { super.consume(delta); serverDataInfo.consume(delta); } }; receiverStream.data(clientDataInfo, new Callback() //TODO: timeout??? { @Override public void succeeded() { if (LOG.isDebugEnabled()) LOG.debug("P -> C {} from {} to {}", clientDataInfo, stream, receiverStream); } @Override public void failed(Throwable x) { LOG.debug(x); rst(receiverStream); } }); } }
@Override public void data(DataInfo dataInfo, long timeout, TimeUnit unit, Handler<Void> handler) { try { // Data buffer must be copied, as the ByteBuffer is pooled ByteBuffer byteBuffer = dataInfo.asByteBuffer(false); Buffer buffer = byteBuffer.isDirect() ? new DirectNIOBuffer(byteBuffer, false) : new IndirectNIOBuffer(byteBuffer, false); generator.addContent(buffer, dataInfo.isClose()); generator.flush(unit.toMillis(timeout)); if (dataInfo.isClose()) complete(); handler.completed(null); } catch (IOException x) { handler.failed(null, x); } }
@Override public void onData(Stream stream, final DataInfo dataInfo) { if (LOG.isDebugEnabled()) LOG.debug("Received {} on {}", dataInfo, stream); HttpChannelOverSPDY channel = (HttpChannelOverSPDY)stream.getAttribute(CHANNEL_ATTRIBUTE); channel.requestContent(dataInfo, dataInfo.isClose()); }
@Override public void onData(final Stream stream, final DataInfo dataInfo) { logger.debug("S -> P {} on {}", dataInfo, stream); if (replyInfo != null) { if (dataInfo.isClose()) replyInfo.getHeaders().put("content-length", String.valueOf(dataInfo.available())); reply(stream); } data(stream, dataInfo); }
@Override public void onData(Stream clientStream, final DataInfo clientDataInfo) { logger.debug("C -> P {} on {}", clientDataInfo, clientStream); ByteBufferDataInfo serverDataInfo = new ByteBufferDataInfo(clientDataInfo.asByteBuffer(false), clientDataInfo.isClose()) { @Override public void consume(int delta) { super.consume(delta); clientDataInfo.consume(delta); } }; StreamHandler streamHandler = (StreamHandler)clientStream.getAttribute(STREAM_HANDLER_ATTRIBUTE); streamHandler.data(serverDataInfo); }
@Override public void onData(Stream serverStream, final DataInfo serverDataInfo) { if (LOG.isDebugEnabled()) LOG.debug("S -> P pushed {} on {}", serverDataInfo, serverStream); ByteBufferDataInfo clientDataInfo = new ByteBufferDataInfo(serverDataInfo.asByteBuffer(false), serverDataInfo.isClose()) { @Override public void consume(int delta) { super.consume(delta); serverDataInfo.consume(delta); } }; pushStreamPromise.data(clientDataInfo); }
@Override public void onData(Stream serverStream, final DataInfo serverDataInfo) { logger.debug("S -> P pushed {} on {}", serverDataInfo, serverStream); ByteBufferDataInfo clientDataInfo = new ByteBufferDataInfo(serverDataInfo.asByteBuffer(false), serverDataInfo.isClose()) { @Override public void consume(int delta) { super.consume(delta); serverDataInfo.consume(delta); } }; StreamHandler handler = (StreamHandler)serverStream.getAttribute(STREAM_HANDLER_ATTRIBUTE); handler.data(clientDataInfo); } }
ByteBufferDataInfo copyDataInfo = new ByteBufferDataInfo(dataInfo.asByteBuffer(false), dataInfo.isClose(), dataInfo.isCompress())
@Override public void onData(Stream clientStream, final DataInfo clientDataInfo) { if (LOG.isDebugEnabled()) LOG.debug("received clientDataInfo: {} for stream: {}", clientDataInfo, clientStream); DeferredContentProvider contentProvider = (DeferredContentProvider)request.getContent(); contentProvider.offer(clientDataInfo.asByteBuffer(true)); if (clientDataInfo.isClose()) contentProvider.close(); } };
@Override public void onData(Stream clientStream, final DataInfo clientDataInfo) { if (LOG.isDebugEnabled()) LOG.debug("C -> P {} on {}", clientDataInfo, clientStream); ByteBufferDataInfo serverDataInfo = new ByteBufferDataInfo(clientDataInfo.asByteBuffer(false), clientDataInfo.isClose()) { @Override public void consume(int delta) { super.consume(delta); clientDataInfo.consume(delta); } }; StreamPromise streamPromise = (StreamPromise)clientStream.getAttribute(STREAM_PROMISE_ATTRIBUTE); streamPromise.data(serverDataInfo); }
@Override public void succeeded() { bufferPool.release(buffer); IStream stream = getStream(); dataInfo.consume(size); flowControlStrategy.updateWindow(StandardSession.this, stream, -size); if (dataInfo.available() > 0) { // We have written a frame out of this DataInfo, but there is more to write. // We need to keep the correct ordering of frames, to avoid that another // DataInfo for the same stream is written before this one is finished. flush(this, flusher.prepend(this)); } else { super.succeeded(); stream.updateCloseState(dataInfo.isClose(), true); if (stream.isClosed()) removeStream(stream); } }
ByteBufferDataInfo copyDataInfo = new ByteBufferDataInfo(copyByteBuffer, dataInfo.isClose())
@Override public void process(DataInfo dataInfo) { notIdle(); // TODO: in v3 we need to send a rst instead of just ignoring // ignore data frame if this stream is remotelyClosed already if (isRemotelyClosed()) { if (LOG.isDebugEnabled()) LOG.debug("Stream is remotely closed, ignoring {}", dataInfo); return; } if (!canReceive()) { if (LOG.isDebugEnabled()) LOG.debug("Protocol error receiving {}, resetting", dataInfo); session.rst(new RstInfo(getId(), StreamStatus.PROTOCOL_ERROR), Callback.Adapter.INSTANCE); return; } updateCloseState(dataInfo.isClose(), false); notifyOnData(dataInfo); }