@Override public boolean readable() { return buffer.readable(); }
@Override void decode(ChannelBuffer headerBlock, SpdyHeadersFrame frame) throws Exception { if (headerBlock == null) { throw new NullPointerException("headerBlock"); } if (frame == null) { throw new NullPointerException("frame"); } if (cumulation == null) { decodeHeaderBlock(headerBlock, frame); if (headerBlock.readable()) { cumulation = ChannelBuffers.dynamicBuffer(headerBlock.readableBytes()); cumulation.writeBytes(headerBlock); } } else { cumulation.writeBytes(headerBlock); decodeHeaderBlock(cumulation, frame); if (cumulation.readable()) { cumulation.discardReadBytes(); } else { cumulation = null; } } }
@Override protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) throws Exception { buffer.markReaderIndex(); final byte[] buf = new byte[5]; for (int i = 0; i < buf.length; i ++) { if (!buffer.readable()) { buffer.resetReaderIndex(); return null; } buf[i] = buffer.readByte(); if (buf[i] >= 0) { int length = CodedInputStream.newInstance(buf, 0, i + 1).readRawVarint32(); if (length < 0) { throw new CorruptedFrameException("negative length: " + length); } if (buffer.readableBytes() < length) { buffer.resetReaderIndex(); return null; } else { return buffer.readBytes(length); } } } // Couldn't find the byte whose MSB is off. throw new CorruptedFrameException("length wider than 32-bit"); } }
@Override public boolean readable() { return buffer.readable(); }
@Override public boolean isReadable() { return buffer.readable(); }
@Override public boolean isReadable() { return buffer.readable(); }
public void setContent(ChannelBuffer content) { if (content == null) { throw new NullPointerException("content"); } last = !content.readable(); this.content = content; }
private static void validateDelimiter(ChannelBuffer delimiter) { if (delimiter == null) { throw new NullPointerException("delimiter"); } if (!delimiter.readable()) { throw new IllegalArgumentException("empty delimiter"); } }
public void setContent(ChannelBuffer content) { if (content == null) { content = ChannelBuffers.EMPTY_BUFFER; } if (content.readable() && isChunked()) { throw new IllegalArgumentException( "non-empty content disallowed if this.chunked == true"); } this.content = content; }
@Override public int read() throws IOException { if (!buffer.readable()) { return -1; } return buffer.readByte() & 0xff; }
public byte readByte() throws IOException { if (!buffer.readable()) { throw new EOFException(); } return buffer.readByte(); }
/** * Creates a new buffer which wraps the specified buffer's readable bytes. * A modification on the specified buffer's content will be visible to the * returned buffer. */ public static ChannelBuffer wrappedBuffer(ChannelBuffer buffer) { if (buffer.readable()) { return buffer.slice(); } else { return EMPTY_BUFFER; } }
public int read() throws IOException { if (buffer.readable()) { return buffer.readByte() & 0xff; } return -1; }
/** * Creates a new buffer whose content is a copy of the specified * {@code buffer}'s readable bytes. The new buffer's {@code readerIndex} * and {@code writerIndex} are {@code 0} and {@code buffer.readableBytes} * respectively. */ public static ChannelBuffer copiedBuffer(ChannelBuffer buffer) { if (buffer.readable()) { return buffer.copy(); } else { return EMPTY_BUFFER; } }
public boolean readable() { return terminated? buf().readable() : true; }
private Event extractEvent(ChannelBuffer in, SocketAddress remoteAddress) { Map<String, String> headers = new HashMap<String,String>(); headers.put(remoteHostHeader, remoteAddress.toString()); byte b = 0; ByteArrayOutputStream baos = new ByteArrayOutputStream(); Event e = null; boolean doneReading = false; try { while (!doneReading && in.readable()) { b = in.readByte(); // Entries are separated by '\n' if (b == '\n') { doneReading = true; } else { baos.write(b); } } e = EventBuilder.withBody(baos.toByteArray(), headers); } finally { // no-op } return e; }
protected ChannelBuffer appendToCumulation(ChannelBuffer input) { ChannelBuffer cumulation = this.cumulation; assert cumulation.readable(); if (cumulation instanceof CompositeChannelBuffer) { // Make sure the resulting cumulation buffer has no more than the configured components. CompositeChannelBuffer composite = (CompositeChannelBuffer) cumulation; if (composite.numComponents() >= maxCumulationBufferComponents) { cumulation = composite.copy(); } } this.cumulation = input = ChannelBuffers.wrappedBuffer(cumulation, input); return input; }
private void callDecode( ChannelHandlerContext context, Channel channel, ChannelBuffer cumulation, SocketAddress remoteAddress) throws Exception { while (cumulation.readable()) { int oldReaderIndex = cumulation.readerIndex(); Object frame = decode(context, channel, cumulation); if (frame == null) { if (oldReaderIndex == cumulation.readerIndex()) { // Seems like more data is required. // Let us wait for the next notification. break; } else { // Previous data has been discarded. // Probably it is reading on. continue; } } if (oldReaderIndex == cumulation.readerIndex()) { throw new IllegalStateException( "decode() method must read at least one byte " + "if it returned a frame (caused by: " + getClass() + ')'); } unfoldAndFireMessageReceived(context, remoteAddress, frame); } }
private ChannelFuture getMessageFuture( ChannelHandlerContext ctx, MessageEvent e, int streamId, HttpMessage httpMessage) { if (!httpMessage.getContent().readable()) { return e.getFuture(); } // Create SPDY Data Frames out of message content SpdyDataFrame[] spdyDataFrames = createSpdyDataFrames(streamId, httpMessage.getContent()); if (spdyDataFrames.length > 0) { spdyDataFrames[spdyDataFrames.length - 1].setLast(true); } return getDataFuture(ctx, e.getFuture(), spdyDataFrames, e.getRemoteAddress()); }
private SpdySynReplyFrame createSynReplyFrame(HttpResponse httpResponse) throws Exception { boolean chunked = httpResponse.isChunked(); // Get the Stream-ID from the headers int streamId = SpdyHttpHeaders.getStreamId(httpResponse); SpdyHttpHeaders.removeStreamId(httpResponse); // The Connection, Keep-Alive, Proxy-Connection, and Transfer-Encoding // headers are not valid and MUST not be sent. httpResponse.headers().remove(HttpHeaders.Names.CONNECTION); httpResponse.headers().remove("Keep-Alive"); httpResponse.headers().remove("Proxy-Connection"); httpResponse.headers().remove(HttpHeaders.Names.TRANSFER_ENCODING); SpdySynReplyFrame spdySynReplyFrame = new DefaultSpdySynReplyFrame(streamId); spdySynReplyFrame.setLast(!chunked && !httpResponse.getContent().readable()); // Unfold the first line of the response into name/value pairs SpdyHeaders.setStatus(spdyVersion, spdySynReplyFrame, httpResponse.getStatus()); SpdyHeaders.setVersion(spdyVersion, spdySynReplyFrame, httpResponse.getProtocolVersion()); // Transfer the remaining HTTP headers for (Map.Entry<String, String> entry: httpResponse.headers()) { spdySynReplyFrame.headers().add(entry.getKey(), entry.getValue()); } return spdySynReplyFrame; }