/** * Sets the {@code "Host"} header. */ public static void setHost(HttpMessage message, String value) { message.headers().set(Names.HOST, value); }
private void decrement(Object msg) { if (msg == null) { return; } // check if its a HttpMessage and its not chunked if (msg instanceof HttpMessage && !((HttpMessage) msg).isChunked()) { requestResponseCounter.decrementAndGet(); } else if (msg instanceof HttpChunk && ((HttpChunk) msg).isLast()) { requestResponseCounter.decrementAndGet(); } else if (msg instanceof Object[]) { // we just decrement it here as we only use this if the end of the chunk is reached // It would be more safe to check all the objects in the array but would also be slower requestResponseCounter.decrementAndGet(); } } @Override
protected void appendToCumulation(ChannelBuffer input) { ChannelBuffer cumulation = currentMessage.getContent(); 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) { currentMessage.setContent(ChannelBuffers.wrappedBuffer(composite.copy(), input)); } else { List<ChannelBuffer> decomposed = composite.decompose(0, composite.readableBytes()); ChannelBuffer[] buffers = decomposed.toArray(new ChannelBuffer[decomposed.size() + 1]); buffers[buffers.length - 1] = input; currentMessage.setContent(ChannelBuffers.wrappedBuffer(buffers)); } } else { currentMessage.setContent(ChannelBuffers.wrappedBuffer(cumulation, input)); } }
/** * Returns {@code true} if and only if the connection can remain open and * thus 'kept alive'. This methods respects the value of the * {@code "Connection"} header first and then the return value of * {@link HttpVersion#isKeepAliveDefault()}. */ public static boolean isKeepAlive(HttpMessage message) { String connection = message.headers().get(Names.CONNECTION); boolean close = Values.CLOSE.equalsIgnoreCase(connection); if (close) { return false; } if (message.getProtocolVersion().isKeepAliveDefault()) { return !close; } else { return Values.KEEP_ALIVE.equalsIgnoreCase(connection); } }
String contentEncoding = m.headers().get(HttpHeaders.Names.CONTENT_ENCODING); if (contentEncoding != null) { contentEncoding = contentEncoding.trim(); boolean hasContent = m.isChunked() || m.getContent().readable(); if (hasContent && (decoder = newContentDecoder(contentEncoding)) != null) { m.headers().remove(HttpHeaders.Names.CONTENT_ENCODING); } else { m.headers().set(HttpHeaders.Names.CONTENT_ENCODING, targetContentEncoding); if (!m.isChunked()) { ChannelBuffer content = m.getContent(); m.setContent(content); if (m.headers().contains(HttpHeaders.Names.CONTENT_LENGTH)) { m.headers().set( HttpHeaders.Names.CONTENT_LENGTH, Integer.toString(content.readableBytes()));
private SpdySynStreamFrame createSynStreamFrame(HttpMessage httpMessage) throws Exception { boolean chunked = httpMessage.isChunked(); httpMessage.headers().remove(HttpHeaders.Names.CONNECTION); httpMessage.headers().remove("Keep-Alive"); httpMessage.headers().remove("Proxy-Connection"); httpMessage.headers().remove(HttpHeaders.Names.TRANSFER_ENCODING); spdySynStreamFrame.setLast(!chunked && !httpMessage.getContent().readable()); SpdyHeaders.setMethod(spdyVersion, spdySynStreamFrame, httpRequest.getMethod()); SpdyHeaders.setUrl(spdyVersion, spdySynStreamFrame, httpRequest.getUri()); SpdyHeaders.setVersion(spdyVersion, spdySynStreamFrame, httpMessage.getProtocolVersion()); SpdyHeaders.setStatus(spdyVersion, spdySynStreamFrame, httpResponse.getStatus()); SpdyHeaders.setUrl(spdyVersion, spdySynStreamFrame, URL); SpdyHeaders.setVersion(spdyVersion, spdySynStreamFrame, httpMessage.getProtocolVersion()); spdySynStreamFrame.setUnidirectional(true); httpMessage.headers().remove(HttpHeaders.Names.HOST); SpdyHeaders.setHost(spdySynStreamFrame, host); for (Map.Entry<String, String> entry: httpMessage.headers()) { spdySynStreamFrame.headers().add(entry.getKey(), entry.getValue());
if (m.isChunked()) { m.setChunked(false); this.currentMessage = m; } else { ChannelBuffer content = currentMessage.getContent(); HttpChunkTrailer trailer = (HttpChunkTrailer) chunk; for (Entry<String, String> header: trailer.trailingHeaders()) { currentMessage.headers().set(header.getKey(), header.getValue()); currentMessage.headers().set( HttpHeaders.Names.CONTENT_LENGTH, String.valueOf(content.readableBytes()));
HttpMessage m = (HttpMessage) msg; boolean contentMustBeEmpty; if (m.isChunked()) { m.headers().add(Names.TRANSFER_ENCODING, Values.CHUNKED); header.writeByte(LF); ChannelBuffer content = m.getContent(); if (!content.readable()) { return header; // no content
if (currentMessage == null) { HttpMessage m = (HttpMessage) msg; if (m.isChunked()) { String localName = UUID.randomUUID().toString(); List<String> encodings = m.headers().getAll(HttpHeaders.Names.TRANSFER_ENCODING); encodings.remove(HttpHeaders.Values.CHUNKED); if (encodings.isEmpty()) { m.headers().remove(HttpHeaders.Names.TRANSFER_ENCODING); currentMessage.headers().set(HttpHeaders.Names.WARNING, "play.netty.content.length.exceeded"); } else { IOUtils.copyLarge(new ChannelBufferInputStream(chunk.getContent()), this.out); this.out.close(); currentMessage.headers().set( HttpHeaders.Names.CONTENT_LENGTH, String.valueOf(localFile.length())); currentMessage.setContent(new FileChannelBuffer(localFile)); this.out = null; this.currentMessage = null;
if (nextState == State.READ_CHUNK_SIZE) { message.setChunked(true); message.headers().remove(HttpHeaders.Names.TRANSFER_ENCODING); resetState(); return message; message.setChunked(true); message.setChunked(true); return message; toRead = maxChunkSize; if (!message.isChunked()) { message.setChunked(true); return new Object[] {message, new DefaultHttpChunk(buffer.readBytes(toRead))}; } else {
httpMessage.headers().add(e.getKey(), e.getValue()); HttpHeaders.setContentLength(httpMessage, httpMessage.getContent().readableBytes()); removeMessage(streamId); return httpMessage; ChannelBuffer content = httpMessage.getContent(); if (content.readableBytes() > maxContentLength - spdyDataFrame.getData().readableBytes()) { removeMessage(streamId); content = ChannelBuffers.dynamicBuffer(channel.getConfig().getBufferFactory()); content.writeBytes(spdyDataFrame.getData()); httpMessage.setContent(content); } else { content.writeBytes(spdyDataFrame.getData());
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(); }
@Override public void writeRequested(ChannelHandlerContext ctx, MessageEvent e) throws Exception { if (e.getMessage() instanceof HttpChunk) { if (((HttpChunk) e.getMessage()).isLast()) { context.stop(); logDifference(System.nanoTime() - start); LOG.debug("saw last chunk"); } } else if (e.getMessage() instanceof HttpMessage) { if (!((HttpMessage) e.getMessage()).isChunked()) { context.stop(); logDifference(System.nanoTime() - start); } LOG.debug("headers: {}", ((HttpMessage) e.getMessage()).getHeaders()); } else { context.stop(); logDifference(System.nanoTime() - start); } LOG.debug("saw message {}", e.getMessage()); super.writeRequested(ctx, e); }
@Override protected Object decode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception { if (msg instanceof HttpMessage) { String contentType = ((HttpMessage) msg).getHeader( "content-type" ); if (contentType != null) { int semiLoc = contentType.indexOf( ";" ); if (semiLoc > 0) { contentType = contentType.substring( 0, semiLoc ); } contentType = contentType.trim(); if (contentType.equals( "text/stomp" )) { HttpMessage httpMessage = (HttpMessage) msg; ChannelBuffer buffer = httpMessage.getContent(); StompFrame stompFrame = StompFrameCodec.INSTANCE.decode( buffer ); return stompFrame; } } } return msg; }
private Object reset() { HttpMessage message = this.message; ChannelBuffer content = this.content; if (content != null) { message.setContent(content); this.content = null; } resetState(); this.message = null; return message; }
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()); }
public static boolean isKeepAlive(HttpMessage message) { return HttpHeaders.isKeepAlive(message) && message.getProtocolVersion().equals(HttpVersion.HTTP_1_1); }
/** * Copy the provided additional headers to the Netty's HttpMessage. * * @param message * @param headers */ protected void setAdditionalHeaders(HttpMessage message, Map<String, Object> headers) { for (String key : headers.keySet()) { String header = (String)headers.get(key); message.addHeader(key, headerCleanerPattern.matcher(header).replaceAll(" ")); } }
String contentEncoding = m.headers().get(HttpHeaders.Names.CONTENT_ENCODING); if (contentEncoding != null && !HttpHeaders.Values.IDENTITY.equalsIgnoreCase(contentEncoding)) { } else { boolean hasContent = m.isChunked() || m.getContent().readable(); if (hasContent && (encoder = newContentEncoder(m, acceptEncoding)) != null) { m.headers().set( HttpHeaders.Names.CONTENT_ENCODING, getTargetContentEncoding(acceptEncoding)); if (m.isChunked()) { m.headers().remove(HttpHeaders.Names.CONTENT_LENGTH); } else { ChannelBuffer content = m.getContent(); m.setContent(content); if (m.headers().contains(HttpHeaders.Names.CONTENT_LENGTH)) { m.headers().set( HttpHeaders.Names.CONTENT_LENGTH, Integer.toString(content.readableBytes()));