Examples of org.jboss.netty.handler.codec.http.HttpChunk

Package org.jboss.netty.handler.codec.http

Examples of org.jboss.netty.handler.codec.http.HttpChunk

org.jboss.netty.handler.codec.http.HttpChunk
@author The Netty Project (netty-dev@lists.jboss.org) @author Trustin Lee (tlee@redhat.com) @version $Rev: 992 $, $Date: 2009-03-09 17:50:24 +0900 (Mon, 09 Mar 2009) $

            request.addHeader(HttpHeaders.Names.TRANSFER_ENCODING,
                    HttpHeaders.Values.CHUNKED);
            request.setContent(ChannelBuffers.EMPTY_BUFFER);
        } else {
            // get the only one body and set it to the request
            HttpChunk chunk = nextChunk();
            request.setContent(chunk.getContent());
        }
        return request;
    }

View Full Code Here

        }
        // size > 0
        if (currentData != null) {
            // continue to read data
            if (isMultipart) {
                HttpChunk chunk = encodeNextChunkMultipart(size);
                if (chunk != null) {
                    return chunk;
                }
            } else {
                HttpChunk chunk = encodeNextChunkUrlEncoded(size);
                if (chunk != null) {
                    //NextChunk Url from currentData
                    return chunk;
                }
            }
            size = HttpPostBodyUtil.chunkSize - currentBuffer.readableBytes();
        }
        if (! iterator.hasNext()) {
            isLastChunk = true;
            //NextChunk as last non empty from buffer
            buffer = currentBuffer;
            currentBuffer = null;
            return new DefaultHttpChunk(buffer);
        }
        while (size > 0 && iterator.hasNext()) {
            currentData = iterator.next();
            HttpChunk chunk;
            if (isMultipart) {
                chunk = encodeNextChunkMultipart(size);
            } else {
                chunk = encodeNextChunkUrlEncoded(size);
            }

View Full Code Here

                ctx.sendUpstream(e);
            }
        } else {
            // TODO: If less that threshold then in memory
            // Merge the received chunk into the content of the current message.
            final HttpChunk chunk = (HttpChunk) msg;
            if (maxContentLength != -1 && (localFile.length() > (maxContentLength - chunk.getContent().readableBytes()))) {
                currentMessage.setHeader(HttpHeaders.Names.WARNING, "play.netty.content.length.exceeded");
            } else {
                IOUtils.copyLarge(new ChannelBufferInputStream(chunk.getContent()), this.out);


                if (chunk.isLast()) {
                    this.out.flush();
                    this.out.close();


                    currentMessage.setHeader(
                            HttpHeaders.Names.CONTENT_LENGTH,

View Full Code Here


        if (ctx.getAttachment() instanceof DiscardEvent) {
            return;
        } else if (ctx.getAttachment() instanceof AsyncCallable) {
            if (e.getMessage() instanceof HttpChunk) {
                HttpChunk chunk = (HttpChunk) e.getMessage();
                if (chunk.isLast()) {
                    AsyncCallable ac = (AsyncCallable) ctx.getAttachment();
                    ac.call();
                } else {
                    return;
                }
            } else {
                AsyncCallable ac = (AsyncCallable) ctx.getAttachment();
                ac.call();
            }
            ctx.setAttachment(new DiscardEvent());
            return;
        } else if (!(ctx.getAttachment() instanceof NettyResponseFuture<?>)) {
            try {
                ctx.getChannel().close();
            } catch (Throwable t) {
                log.trace("Closing an orphan channel {}", ctx.getChannel());
            }
            return;
        }


        final NettyResponseFuture<?> future = (NettyResponseFuture<?>) ctx.getAttachment();
        future.touch();


        // The connect timeout occured.
        if (future.isCancelled() || future.isDone()) {
            finishChannel(ctx);
            return;
        }


        HttpRequest nettyRequest = future.getNettyRequest();
        AsyncHandler<?> handler = future.getAsyncHandler();
        Request request = future.getRequest();
        HttpResponse response = null;
        try {
            if (e.getMessage() instanceof HttpResponse) {
                response = (HttpResponse) e.getMessage();


                log.debug("\n\nRequest {}\n\nResponse {}\n", nettyRequest, response);


                // Required if there is some trailing headers.
                future.setHttpResponse(response);


                int statusCode = response.getStatus().getCode();


                String ka = response.getHeader(HttpHeaders.Names.CONNECTION);
                future.setKeepAlive(ka == null || ka.toLowerCase().equals("keep-alive"));


                List<String> wwwAuth = getAuthorizationToken(response.getHeaders(), HttpHeaders.Names.WWW_AUTHENTICATE);
                Realm realm = request.getRealm() != null ? request.getRealm() : config.getRealm();


                HttpResponseStatus status = new ResponseStatus(future.getURI(), response, this);
                FilterContext<?> fc = new FilterContext.FilterContextBuilder().asyncHandler(handler).request(request).responseStatus(status).build();
                for (ResponseFilter asyncFilter : config.getResponseFilters()) {
                    try {
                        fc = asyncFilter.filter(fc);
                        if (fc == null) {
                            throw new NullPointerException("FilterContext is null");
                        }
                    } catch (FilterException efe) {
                        abort(future, efe);
                    }
                }


                // The request has changed
                if (fc.replayRequest()) {
                    replayRequest(future, fc, response, ctx);
                    return;
                }


                Realm newRealm = null;
                ProxyServer proxyServer = request.getProxyServer() != null ? request.getProxyServer() : config.getProxyServer();
                final FluentCaseInsensitiveStringsMap headers = request.getHeaders();
                final RequestBuilder builder = new RequestBuilder(future.getRequest());


                if (realm != null && !future.getURI().getPath().equalsIgnoreCase(realm.getUri())) {
                    builder.setUrl(future.getURI().toString());
                }


                if (statusCode == 401
                        && wwwAuth.size() > 0
                        && !future.getAndSetAuth(true)) {


                    future.setState(NettyResponseFuture.STATE.NEW);
                    // NTLM
                    if ( !wwwAuth.contains("Kerberos") && (wwwAuth.contains("NTLM") || (wwwAuth.contains("Negotiate"))) ) {
                        newRealm = ntlmChallenge(wwwAuth, request, proxyServer, headers, realm, future);
                        // SPNEGO KERBEROS
                    } else if (wwwAuth.contains("Negotiate")) {
                        newRealm = kerberosChallenge(wwwAuth, request, proxyServer, headers, realm, future );
                        if (newRealm == null) return;
                    } else {
                        Realm.RealmBuilder realmBuilder;
                        if (realm != null) {
                            realmBuilder = new Realm.RealmBuilder().clone(realm).setScheme(realm.getAuthScheme())
;
                        } else {
                            realmBuilder = new Realm.RealmBuilder();
                        }
                        newRealm = realmBuilder
                                .setUri(URI.create(request.getUrl()).getPath())
                                .setMethodName(request.getMethod())
                                .setUsePreemptiveAuth(true)
                                .parseWWWAuthenticateHeader(wwwAuth.get(0))
                                .build();
                    }


                    final Realm nr = newRealm;


                    log.debug("Sending authentication to {}", request.getUrl());
                    AsyncCallable ac = new AsyncCallable(future) {
                        public Object call() throws Exception {
                            drainChannel(ctx, future, future.getKeepAlive(), future.getURI());
                            nextRequest(builder.setHeaders(headers).setRealm(nr).build(), future);
                            return null;
                        }
                    };


                    if (future.getKeepAlive() && response.isChunked()) {
                        // We must make sure there is no bytes left before executing the next request.
                        ctx.setAttachment(ac);
                    } else {
                        ac.call();
                    }
                    return;
                }


                if (statusCode == 100) {
                    future.getAndSetWriteHeaders(false);
                    future.getAndSetWriteBody(true);
                    writeRequest(ctx.getChannel(), config, future, nettyRequest);
                    return;
                }


                List<String> proxyAuth = getAuthorizationToken(response.getHeaders(), HttpHeaders.Names.PROXY_AUTHENTICATE);
                if (statusCode == 407
                        && proxyAuth.size() > 0
                        && !future.getAndSetAuth(true)) {


                    log.debug("Sending proxy authentication to {}", request.getUrl());


                    future.setState(NettyResponseFuture.STATE.NEW);
                    if (!proxyAuth.contains("Kerberos") && (proxyAuth.contains("NTLM") || (proxyAuth.contains("Negotiate")))) {
                        newRealm = ntlmChallenge(proxyAuth, request, proxyServer, headers, realm, future);
                        // SPNEGO KERBEROS
                    } else if (proxyAuth.contains("Negotiate")) {
                        newRealm = kerberosChallenge(proxyAuth, request, proxyServer, headers, realm, future);
                        if (newRealm == null) return;
                    } else {
                        newRealm = future.getRequest().getRealm();
                    }


                    nextRequest(builder.setHeaders(headers).setRealm(newRealm).build(), future);
                    return;
                }


                if (future.getNettyRequest().getMethod().equals(HttpMethod.CONNECT)
                        && statusCode == 200) {


                    log.debug("Connected to {}:{}", proxyServer.getHost(), proxyServer.getPort());


                    if (future.getKeepAlive()) {
                        future.attachChannel(ctx.getChannel(), true);
                    }


                    try {
                        log.debug("Connecting to proxy {} for scheme {}", proxyServer, request.getUrl());
                        upgradeProtocol(ctx.getChannel().getPipeline(), request.getUrl());
                    } catch (Throwable ex) {
                        abort(future, ex);
                    }
                    nextRequest(builder.build(), future);
                    return;
                }


                boolean redirectEnabled = request.isRedirectEnabled() ? true : config.isRedirectEnabled();
                if (redirectEnabled && (statusCode == 302 || statusCode == 301)) {


                    if (future.incrementAndGetCurrentRedirectCount() < config.getMaxRedirects()) {
                        // We must allow 401 handling again.
                        future.getAndSetAuth(false);


                        String location = response.getHeader(HttpHeaders.Names.LOCATION);
                        URI uri = AsyncHttpProviderUtils.getRedirectUri(future.getURI(), location);
                        boolean stripQueryString = config.isRemoveQueryParamOnRedirect();


                        if (!uri.toString().equalsIgnoreCase(future.getURI().toString())) {
                            final RequestBuilder nBuilder = stripQueryString ?
                                    new RequestBuilder(future.getRequest()).setQueryParameters(null)
                                    : new RequestBuilder(future.getRequest());


                            final URI initialConnectionUri = future.getURI();
                            final boolean initialConnectionKeepAlive = future.getKeepAlive();
                            future.setURI(uri);
                            final String newUrl = uri.toString();


                            log.debug("Redirecting to {}", newUrl);
                            for(String cookieStr : future.getHttpResponse().getHeaders(HttpHeaders.Names.SET_COOKIE)){
                                Cookie c = AsyncHttpProviderUtils.parseCookie(cookieStr);
                                nBuilder.addOrReplaceCookie(c);
                            }


                            for(String cookieStr : future.getHttpResponse().getHeaders(HttpHeaders.Names.SET_COOKIE2)){
                                Cookie c = AsyncHttpProviderUtils.parseCookie(cookieStr);
                                nBuilder.addOrReplaceCookie(c);
                            }


                            AsyncCallable ac = new AsyncCallable(future) {
                                public Object call() throws Exception {
                                    if (initialConnectionKeepAlive && ctx.getChannel().isReadable() &&
                                            connectionsPool.offer(AsyncHttpProviderUtils.getBaseUrl(initialConnectionUri), ctx.getChannel())) {
                                        return null;
                                    }
                                    finishChannel(ctx);
                                    return null;
                                }
                            };


                            if (response.isChunked()) {
                                // We must make sure there is no bytes left before executing the next request.
                                ctx.setAttachment(ac);
                            } else {
                                ac.call();
                            }
                            nextRequest(nBuilder.setUrl(newUrl).build(), future);
                            return;
                        }
                    } else {
                        throw new MaxRedirectException("Maximum redirect reached: " + config.getMaxRedirects());
                    }
                }


                if (!future.getAndSetStatusReceived(true) && updateStatusAndInterrupt(handler, status)) {
                    finishUpdate(future, ctx, response.isChunked());
                    return;
                } else if (updateHeadersAndInterrupt(handler, new ResponseHeaders(future.getURI(), response, this))) {
                    finishUpdate(future, ctx, response.isChunked());
                    return;
                } else if (!response.isChunked()) {
                    if (response.getContent().readableBytes() != 0) {
                        updateBodyAndInterrupt(handler, new ResponseBodyPart(future.getURI(), response, this));
                    }
                    finishUpdate(future, ctx, false);
                    return;
                }


                if (nettyRequest.getMethod().equals(HttpMethod.HEAD)) {
                    updateBodyAndInterrupt(handler, new ResponseBodyPart(future.getURI(), response, this));
                    markAsDone(future, ctx);
                    drainChannel(ctx, future, future.getKeepAlive(), future.getURI());
                }


            } else if (e.getMessage() instanceof HttpChunk) {
                HttpChunk chunk = (HttpChunk) e.getMessage();


                if (handler != null) {
                    if (chunk.isLast() || updateBodyAndInterrupt(handler, new ResponseBodyPart(future.getURI(), null, this, chunk))) {
                        if (chunk instanceof DefaultHttpChunkTrailer) {
                            updateHeadersAndInterrupt(handler, new ResponseHeaders(future.getURI(),
                                    future.getHttpResponse(), this, (HttpChunkTrailer) chunk));
                        }
                        finishUpdate(future, ctx, !chunk.isLast());
                    }
                }
            }
        } catch (Exception t) {
            if (IOException.class.isAssignableFrom(t.getClass()) && config.getIOExceptionFilters().size() > 0) {

View Full Code Here

            return reset(ctx, channel);
        }
        case READ_VARIABLE_LENGTH_CONTENT_AS_CHUNKS: {
            // Keep reading data as a chunk until the end of connection is reached.
            int chunkSize = Math.min(maxChunkSize, buffer.readableBytes());
            HttpChunk chunk = new DefaultHttpChunk(buffer.readBytes(chunkSize));


            if (!buffer.readable()) {
                // Reached to the end of the connection.
                reset(ctx, channel);
                if (!chunk.isLast()) {
                    // Append the last chunk.
                    return new Object[] { chunk, HttpChunk.LAST_CHUNK };
                }
            }
            return chunk;
        }
        case READ_FIXED_LENGTH_CONTENT: {
            //we have a content-length so we just read the correct number of bytes
            readFixedLengthContent(buffer);
            return reset(ctx, channel);
        }
        case READ_FIXED_LENGTH_CONTENT_AS_CHUNKS: {
            long chunkSize = this.chunkSize;
            HttpChunk chunk;
            if (chunkSize > maxChunkSize) {
                chunk = new DefaultHttpChunk(buffer.readBytes(maxChunkSize));
                chunkSize -= maxChunkSize;
            } else {
                assert chunkSize <= Integer.MAX_VALUE;
                chunk = new DefaultHttpChunk(buffer.readBytes((int) chunkSize));
                chunkSize = 0;
            }
            this.chunkSize = chunkSize;


            if (chunkSize == 0) {
                // Read all content.
                reset(ctx, channel);
                if (!chunk.isLast()) {
                    // Append the last chunk.
                    return new Object[] { chunk, HttpChunk.LAST_CHUNK };
                }
            }
            return chunk;
        }
        /**
         * everything else after this point takes care of reading chunked content. basically, read chunk size,
         * read chunk, read and ignore the CRLF and repeat until 0
         */
        case READ_CHUNK_SIZE: {
            String line = readLine(buffer, maxInitialLineLength);
            int chunkSize = getChunkSize(line);
            this.chunkSize = chunkSize;
            if (chunkSize == 0) {
                checkpoint(State.READ_CHUNK_FOOTER);
                return null;
            } else if (chunkSize > maxChunkSize) {
                // A chunk is too large. Split them into multiple chunks again.
                checkpoint(State.READ_CHUNKED_CONTENT_AS_CHUNKS);
            } else {
                checkpoint(State.READ_CHUNKED_CONTENT);
            }
        }
        case READ_CHUNKED_CONTENT: {
            assert chunkSize <= Integer.MAX_VALUE;
            HttpChunk chunk = new DefaultHttpChunk(buffer.readBytes((int) chunkSize));
            checkpoint(State.READ_CHUNK_DELIMITER);
            return chunk;
        }
        case READ_CHUNKED_CONTENT_AS_CHUNKS: {
            long chunkSize = this.chunkSize;
            HttpChunk chunk;
            if (chunkSize > maxChunkSize) {
                chunk = new DefaultHttpChunk(buffer.readBytes(maxChunkSize));
                chunkSize -= maxChunkSize;
            } else {
                assert chunkSize <= Integer.MAX_VALUE;
                chunk = new DefaultHttpChunk(buffer.readBytes((int) chunkSize));
                chunkSize = 0;
            }
            this.chunkSize = chunkSize;


            if (chunkSize == 0) {
                // Read all content.
                checkpoint(State.READ_CHUNK_DELIMITER);
            }


            if (!chunk.isLast()) {
                return chunk;
            }
        }
        case READ_CHUNK_DELIMITER: {
            for (;;) {

View Full Code Here

        // store response, as this channel handler is created per pipeline
        Object msg = messageEvent.getMessage();


        // it may be a chunked message
        if (msg instanceof HttpChunk) {
            HttpChunk chunk = (HttpChunk) msg;
            if (LOG.isTraceEnabled()) {
                LOG.trace("HttpChunk received: {} isLast: {}", chunk, chunk.isLast());
            }


            if (msg instanceof HttpChunkTrailer) {
                // chunk trailer only has headers
                HttpChunkTrailer trailer = (HttpChunkTrailer) msg;
                for (Map.Entry<String, String> entry : trailer.getHeaders()) {
                    if (LOG.isTraceEnabled()) {
                        LOG.trace("Adding trailing header {}={}", entry.getKey(), entry.getValue());
                    }
                    response.addHeader(entry.getKey(), entry.getValue());
                }
            } else {
                // append chunked content
                buffer.writeBytes(chunk.getContent());
                if (LOG.isTraceEnabled()) {
                    LOG.trace("Wrote {} bytes to chunk buffer", buffer.writerIndex());
                }
            }
            if (chunk.isLast()) {
                // the content is a copy of the buffer with the actual data we wrote to it
                int end = buffer.writerIndex();
                ChannelBuffer copy = buffer.copy(0, end);
                // the copy must not be readable when the content was chunked, so set the index to the end
                copy.setIndex(end, end);

View Full Code Here

            System.out.println(content.toString(CharsetUtil.UTF_8));
            System.out.println("} END OF CONTENT");
          }
        }
      } else {
        HttpChunk chunk = (HttpChunk) e.getMessage();
        if (chunk.isLast()) {
          readingChunks = false;
          System.out.println("} END OF CHUNKED CONTENT");
        } else {
          System.out.print(chunk.getContent().toString(CharsetUtil.UTF_8));
          System.out.flush();
        }
      }
    }

View Full Code Here

    setReceivedFuture(channelFuture);
    if (this.partialResponse == null) {
      this.partialResponse = new StringBuilder();
    }
    if (readingChunks) {
      HttpChunk chunk = (HttpChunk) event.getMessage();
      if (chunk.isLast()) {
        readingChunks = false;
      } else {
        String curChunk = chunk.getContent().toString("UTF-8");
        /*
         * Server sends four new lines in a chunk as a sentinal between
         * responses.
         */
        if (curChunk.matches("\n\n\n\n")) {

View Full Code Here

    setReceivedFuture(channelFuture);
    if (this.partialResponse == null) {
      this.partialResponse = new StringBuilder();
    }
    if (readingChunks) {
      HttpChunk chunk = (HttpChunk) event.getMessage();
      if (chunk.isLast()) {
        readingChunks = false;
      } else {
        String curChunk = chunk.getContent().toString("UTF-8");
        /*
         * Server sends four new lines in a chunk as a sentinal between
         * responses.
         */
        if (curChunk.matches("\n\n\n\n")) {

View Full Code Here

                    }
                    // Reached to the end of response - close the request.
                    closeReal(succeededFuture(virtualChannel));
                }
            } else {
                HttpChunk chunk = (HttpChunk) e.getMessage();
                if (!chunk.isLast()) {
                    fireMessageReceived(HttpTunnelingClientSocketChannel.this, chunk.getContent());
                } else {
                    readingChunks = false;
                    // Reached to the end of response - close the request.
                    closeReal(succeededFuture(virtualChannel));
                }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.jboss.netty.handler.codec.http.HttpChunk

co.adhoclabs.ironcushion.bulkinsert.BulkInsertHandler

com.anthavio.httl.NettySender$HttpResponseHandler

com.bj58.spat.gaea.server.core.communication.http.HttpHandler

com.couchbase.client.vbucket.BucketUpdateResponseHandler

com.linkedin.databus.client.netty.TestGenericHttpResponseHandler

com.linkedin.databus.client.netty.TestNettyHttpDatabusBootstrapConnection

com.linkedin.databus.client.netty.TestNettyHttpDatabusRelayConnection

com.linkedin.databus.client.netty.TestResponseProcessors

com.linkedin.databus.client.TestDatabusHttpClient

com.linkedin.databus.core.test.netty.FooterAwareHttpChunkAggregator

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.