if (isLastChunk) { isLastChunkSent = true; return new DefaultHttpChunk(ChannelBuffers.EMPTY_BUFFER); return new DefaultHttpChunk(buffer); return new DefaultHttpChunk(buffer); isLastChunkSent = true; return new DefaultHttpChunk(ChannelBuffers.EMPTY_BUFFER); return new DefaultHttpChunk(buffer);
/** * Creates a new instance with the specified chunk content. If an empty * buffer is specified, this chunk becomes the 'end of content' marker. */ public DefaultHttpChunk(ChannelBuffer content) { setContent(content); }
void writeReal(final ChannelBuffer a, final ChannelFuture future) { if (!requestHeaderWritten) { throw new NotYetConnectedException(); } final int size = a.readableBytes(); final ChannelFuture f; if (size == 0) { f = realChannel.write(ChannelBuffers.EMPTY_BUFFER); } else { f = realChannel.write(new DefaultHttpChunk(a)); } f.addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture f) { if (f.isSuccess()) { future.setSuccess(); if (size != 0) { fireWriteComplete(HttpTunnelingClientSocketChannel.this, size); } } else { future.setFailure(f.getCause()); } } }); }
private Object readFixedLengthContent(ChannelBuffer buffer) { //we have a content-length so we just read the correct number of bytes long length = HttpHeaders.getContentLength(message, -1); assert length <= Integer.MAX_VALUE; int toRead = (int) length - contentRead; if (toRead > actualReadableBytes()) { toRead = actualReadableBytes(); } contentRead += toRead; if (length < contentRead) { if (!message.isChunked()) { message.setChunked(true); return new Object[] {message, new DefaultHttpChunk(buffer.readBytes(toRead))}; } else { return new DefaultHttpChunk(buffer.readBytes(toRead)); } } if (content == null) { content = buffer.readBytes((int) length); } else { content.writeBytes(buffer, (int) length); } return reset(); }
long chunkNum = 0; while (it.hasNext()) { final DefaultHttpChunk chunk = new DefaultHttpChunk( new BigEndianHeapChannelBuffer(it.next())
@Test public void simpleMultiStreamTest() throws IOException { Iterator<byte[]> it = BYTE_LIST.iterator(); SequenceInputStreamResponseHandler responseHandler = new SequenceInputStreamResponseHandler(); final HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK); response.setChunked(true); ClientResponse<InputStream> clientResponse = responseHandler.handleResponse(response, null); long chunkNum = 0; while (it.hasNext()) { final DefaultHttpChunk chunk = new DefaultHttpChunk(new BigEndianHeapChannelBuffer(it.next())); clientResponse = responseHandler.handleChunk(clientResponse, chunk, ++chunkNum); } clientResponse = responseHandler.done(clientResponse); final InputStream stream = clientResponse.getObj(); final InputStream expectedStream = new ByteArrayInputStream(allBytes); int read = 0; while (read < allBytes.length) { final byte[] expectedBytes = new byte[Math.min(RANDOM.nextInt(128), allBytes.length - read)]; final byte[] actualBytes = new byte[expectedBytes.length]; fillBuff(stream, actualBytes); fillBuff(expectedStream, expectedBytes); Assert.assertArrayEquals(expectedBytes, actualBytes); read += expectedBytes.length; } Assert.assertEquals(allBytes.length, responseHandler.getByteCount()); }
return new DefaultHttpChunk(buffer); return new DefaultHttpChunk(buffer); return new DefaultHttpChunk(buffer);
@Test public void alignedMultiStreamTest() throws IOException { Iterator<byte[]> it = BYTE_LIST.iterator(); SequenceInputStreamResponseHandler responseHandler = new SequenceInputStreamResponseHandler(); final HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK); response.setChunked(true); ClientResponse<InputStream> clientResponse = responseHandler.handleResponse(response, null); long chunkNum = 0; while (it.hasNext()) { final DefaultHttpChunk chunk = new DefaultHttpChunk(new BigEndianHeapChannelBuffer(it.next())); clientResponse = responseHandler.handleChunk(clientResponse, chunk, ++chunkNum); } clientResponse = responseHandler.done(clientResponse); final InputStream stream = clientResponse.getObj(); final InputStream expectedStream = new ByteArrayInputStream(allBytes); for (byte[] bytes : BYTE_LIST) { final byte[] expectedBytes = new byte[bytes.length]; final byte[] actualBytes = new byte[expectedBytes.length]; fillBuff(stream, actualBytes); fillBuff(expectedStream, expectedBytes); Assert.assertArrayEquals(expectedBytes, actualBytes); Assert.assertArrayEquals(expectedBytes, bytes); } Assert.assertEquals(allBytes.length, responseHandler.getByteCount()); }
return new DefaultHttpChunk(buffer);
return new Object[] {message, new DefaultHttpChunk(buffer.readBytes(toRead))}; } else { return new DefaultHttpChunk(buffer.readBytes(toRead)); toRead = maxChunkSize; HttpChunk chunk = new DefaultHttpChunk(buffer.readBytes(toRead)); toRead = (int) chunkSize; HttpChunk chunk = new DefaultHttpChunk(buffer.readBytes(toRead)); if (chunkSize > toRead) { chunkSize -= toRead; HttpChunk chunk = new DefaultHttpChunk(buffer.readBytes((int) chunkSize)); checkpoint(State.READ_CHUNK_DELIMITER); return chunk; toRead = readLimit; HttpChunk chunk = new DefaultHttpChunk(buffer.readBytes(toRead)); if (chunkSize > toRead) { chunkSize -= toRead;
Channels.write( ctx, Channels.succeededFuture(e.getChannel()), new DefaultHttpChunk(lastProduct), e.getRemoteAddress());
ctx, new DefaultHttpChunk(lastProduct), e.getRemoteAddress());
@Override public NettyHttpResponse write(String content) { if (response.isChunked()) { ctx.getChannel().write(new DefaultHttpChunk(wrappedBuffer(content.getBytes(CharsetUtil.UTF_8)))); } else { write(copiedBuffer(content, CharsetUtil.UTF_8)); } return this; }
private void flushResponse() { try { // TODO: Shouldn't have to do this, but without it we sometimes seem to get two Content-Length headers in the response. header("Content-Length", (String) null); header("Content-Length", responseBuffer.readableBytes()); ChannelFuture future = response.isChunked() ? ctx.getChannel().write(new DefaultHttpChunk(ChannelBuffers.EMPTY_BUFFER)) : write(responseBuffer); if (!isKeepAlive) { future.addListener(ChannelFutureListener.CLOSE); } } catch (Exception e) { exceptionHandler.uncaughtException(Thread.currentThread(), WebbitException.fromException(e, ctx.getChannel())); } }
private void writeEndChunk() { conn.write(new DefaultHttpChunk(ChannelBuffers.EMPTY_BUFFER)); }
@Override public void write(byte[] b, int off, int len) { final ChannelBuffer buffer = ChannelBuffers.copiedBuffer(b, off, len); if (log.isTraceEnabled()) { log.trace("writing data: {}", buffer.toString(Charset.defaultCharset())); } channel.write(new DefaultHttpChunk(buffer)); if (log.isDebugEnabled()) { log.debug("wrote {} bytes as chunk", len); } }
@Override public void write(int b) { ChannelBuffer content = ChannelBuffers.copiedBuffer(new byte[]{(byte) b}); if (log.isTraceEnabled()) { log.trace("writing data: {}", content.toString(Charset.defaultCharset())); } channel.write(new DefaultHttpChunk(content)); } };
@Override protected void writeSequence(ChannelHandlerContext ctx, ChannelFuture future, long sequenceNumber) { // Convert the sequence to a string and then a buffer. ChannelBuffer buffer = ChannelBuffers.copiedBuffer(Long.toString(sequenceNumber), CharsetUtil.UTF_8); // Wrap the buffer in a HTTP chunk. DefaultHttpChunk chunk = new DefaultHttpChunk(buffer); // Pass the chunk downstream. Channels.write(ctx, future, chunk); } }
private void sendChunk(ChannelBuffer buff, Handler<Void> doneHandler) { Object write = chunked ? new DefaultHttpChunk(buff) : buff; ChannelFuture writeFuture = conn.write(write); if (doneHandler != null) { conn.addFuture(doneHandler, writeFuture); } }
/** * Flush the internal buffer */ private void flushBuffer() throws IOException { if (cur > 0) { ChannelBuffer content = ChannelBuffers.copiedBuffer(buffer, 0, cur); HttpChunk chunk = new DefaultHttpChunk(content); if (future != null) { future.awaitUninterruptibly(); } future = channel.write(chunk); cur = 0; } }