Example usage for io.netty.handler.codec.http HttpResponseStatus PARTIAL_CONTENT

List of usage examples for io.netty.handler.codec.http HttpResponseStatus PARTIAL_CONTENT

  1. HOME
  2. Java
  3. io.netty
  4. io.netty.handler.codec.http.*
  5. HttpResponseStatus
  6. PARTIAL_CONTENT

Introduction

In this page you can find the example usage for io.netty.handler.codec.http HttpResponseStatus PARTIAL_CONTENT.

Prototype

HttpResponseStatus PARTIAL_CONTENT

To view the source code for io.netty.handler.codec.http HttpResponseStatus PARTIAL_CONTENT.

Click Source Link

Document

206 Partial Content

Usage

From source file:com.creamsugardonut.HttpStaticFileServerHandler2.java

License:Apache License

@Override
public void channelRead0(ChannelHandlerContext ctx, HttpRequest request) throws Exception {
    if (!request.getDecoderResult().isSuccess()) {
        sendError(ctx, BAD_REQUEST);//w w  w  .j av a  2s. co  m
        return;
    }

    final String uri = request.getUri();
    final String path = sanitizeUri(uri);
    if (path == null) {
        sendError(ctx, FORBIDDEN);
        return;
    }

    File file = new File(path);
    if (file.isHidden() || !file.exists()) {
        sendError(ctx, NOT_FOUND);
        return;
    }

    if (!file.isFile()) {
        sendError(ctx, FORBIDDEN);
        return;
    }

    RandomAccessFile raf;
    try {
        raf = new RandomAccessFile(file, "r");
    } catch (FileNotFoundException ignore) {
        sendError(ctx, NOT_FOUND);
        return;
    }
    long fileLength = raf.length();

    HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
    setContentTypeHeader(response, file);
    if (HttpHeaders.isKeepAlive(request)) {
        response.headers().set(CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
    }

    // Write the content.
    ChannelFuture sendFileFuture;
    ChannelFuture lastContentFuture;

    // Tell clients that Partial Requests are available.
    response.headers().add(HttpHeaders.Names.ACCEPT_RANGES, HttpHeaders.Values.BYTES);

    String rangeHeader = request.headers().get(HttpHeaders.Names.RANGE);
    System.out.println(HttpHeaders.Names.RANGE + " = " + rangeHeader);
    if (rangeHeader != null && rangeHeader.length() > 0) { // Partial Request
        PartialRequestInfo partialRequestInfo = getPartialRequestInfo(rangeHeader, fileLength);

        // Set Response Header
        response.headers().add(HttpHeaders.Names.CONTENT_RANGE, HttpHeaders.Values.BYTES + " "
                + partialRequestInfo.startOffset + "-" + partialRequestInfo.endOffset + "/" + fileLength);
        System.out.println(HttpHeaders.Names.CONTENT_RANGE + " : "
                + response.headers().get(HttpHeaders.Names.CONTENT_RANGE));

        HttpHeaders.setContentLength(response, partialRequestInfo.getChunkSize());
        System.out.println(HttpHeaders.Names.CONTENT_LENGTH + " : " + partialRequestInfo.getChunkSize());

        response.setStatus(HttpResponseStatus.PARTIAL_CONTENT);

        // Write Response
        ctx.write(response);
        sendFileFuture = ctx.write(new DefaultFileRegion(raf.getChannel(), partialRequestInfo.getStartOffset(),
                partialRequestInfo.getChunkSize()), ctx.newProgressivePromise());
    } else {
        // Set Response Header
        HttpHeaders.setContentLength(response, fileLength);

        // Write Response
        ctx.write(response);
        sendFileFuture = ctx.write(new DefaultFileRegion(raf.getChannel(), 0, fileLength),
                ctx.newProgressivePromise());
    }

    lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);

    sendFileFuture.addListener(new ChannelProgressiveFutureListener() {
        @Override
        public void operationProgressed(ChannelProgressiveFuture future, long progress, long total) {
            if (total < 0) { // total unknown
                System.err.println(future.channel() + " Transfer progress: " + progress);
            } else {
                System.err.println(future.channel() + " Transfer progress: " + progress + " / " + total);
            }
        }

        @Override
        public void operationComplete(ChannelProgressiveFuture future) {
            System.err.println(future.channel() + " Transfer complete.");
        }
    });

    // Decide whether to close the connection or not.
    if (!HttpHeaders.isKeepAlive(request)) {
        // Close the connection when the whole content is written out.
        lastContentFuture.addListener(ChannelFutureListener.CLOSE);
    }
}

From source file:net.pms.network.RequestHandlerV2.java

License:Open Source License

private void writeResponse(ChannelHandlerContext ctx, FullHttpRequest e, RequestV2 request, InetAddress ia) {
    // Decide whether to close the connection or not.
    boolean close = HttpHeaders.Values.CLOSE
            .equalsIgnoreCase(nettyRequest.headers().get(HttpHeaders.Names.CONNECTION))
            || nettyRequest.getProtocolVersion().equals(HttpVersion.HTTP_1_0) && !HttpHeaders.Values.KEEP_ALIVE
                    .equalsIgnoreCase(nettyRequest.headers().get(HttpHeaders.Names.CONNECTION));

    // Build the response object.
    HttpResponse response;//from  w w w .  j av  a2s  . co m
    if (request.getLowRange() != 0 || request.getHighRange() != 0) {
        response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.PARTIAL_CONTENT);
    } else {
        String soapAction = nettyRequest.headers().get("SOAPACTION");

        if (soapAction != null && soapAction.contains("X_GetFeatureList")) {
            LOGGER.debug("Invalid action in SOAPACTION: " + soapAction);
            response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR);
        } else {
            response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        }
    }

    StartStopListenerDelegate startStopListenerDelegate = new StartStopListenerDelegate(ia.getHostAddress());
    // Attach it to the context so it can be invoked if connection is reset unexpectedly
    ctx.attr(startStop).set(startStopListenerDelegate);

    try {
        request.answer(ctx, response, e, close, startStopListenerDelegate);
    } catch (IOException e1) {
        LOGGER.trace("HTTP request V2 IO error: " + e1.getMessage());
        // note: we don't call stop() here in a finally block as
        // answer() is non-blocking. we only (may) need to call it
        // here in the case of an exception. it's a no-op if it's
        // already been called
        startStopListenerDelegate.stop();
    }
}

From source file:org.restnext.server.ServerHandler.java

License:Apache License

private HttpResponseStatus fromStatus(Response.Status status) {
    switch (status) {
    case OK://from   w  w w .j ava  2  s  . com
        return HttpResponseStatus.OK;
    case CREATED:
        return HttpResponseStatus.CREATED;
    case ACCEPTED:
        return HttpResponseStatus.ACCEPTED;
    case NO_CONTENT:
        return HttpResponseStatus.NO_CONTENT;
    case RESET_CONTENT:
        return HttpResponseStatus.RESET_CONTENT;
    case PARTIAL_CONTENT:
        return HttpResponseStatus.PARTIAL_CONTENT;
    case MOVED_PERMANENTLY:
        return HttpResponseStatus.MOVED_PERMANENTLY;
    case FOUND:
        return HttpResponseStatus.FOUND;
    case SEE_OTHER:
        return HttpResponseStatus.SEE_OTHER;
    case NOT_MODIFIED:
        return HttpResponseStatus.NOT_MODIFIED;
    case USE_PROXY:
        return HttpResponseStatus.USE_PROXY;
    case TEMPORARY_REDIRECT:
        return HttpResponseStatus.TEMPORARY_REDIRECT;
    case BAD_REQUEST:
        return HttpResponseStatus.BAD_REQUEST;
    case UNAUTHORIZED:
        return HttpResponseStatus.UNAUTHORIZED;
    case PAYMENT_REQUIRED:
        return HttpResponseStatus.PAYMENT_REQUIRED;
    case FORBIDDEN:
        return HttpResponseStatus.FORBIDDEN;
    case NOT_FOUND:
        return HttpResponseStatus.NOT_FOUND;
    case METHOD_NOT_ALLOWED:
        return HttpResponseStatus.METHOD_NOT_ALLOWED;
    case NOT_ACCEPTABLE:
        return HttpResponseStatus.NOT_ACCEPTABLE;
    case PROXY_AUTHENTICATION_REQUIRED:
        return HttpResponseStatus.PROXY_AUTHENTICATION_REQUIRED;
    case REQUEST_TIMEOUT:
        return HttpResponseStatus.REQUEST_TIMEOUT;
    case CONFLICT:
        return HttpResponseStatus.CONFLICT;
    case GONE:
        return HttpResponseStatus.GONE;
    case LENGTH_REQUIRED:
        return HttpResponseStatus.LENGTH_REQUIRED;
    case PRECONDITION_FAILED:
        return HttpResponseStatus.PRECONDITION_FAILED;
    case REQUEST_ENTITY_TOO_LARGE:
        return HttpResponseStatus.REQUEST_ENTITY_TOO_LARGE;
    case REQUEST_URI_TOO_LONG:
        return HttpResponseStatus.REQUEST_URI_TOO_LONG;
    case UNSUPPORTED_MEDIA_TYPE:
        return HttpResponseStatus.UNSUPPORTED_MEDIA_TYPE;
    case REQUESTED_RANGE_NOT_SATISFIABLE:
        return HttpResponseStatus.REQUESTED_RANGE_NOT_SATISFIABLE;
    case EXPECTATION_FAILED:
        return HttpResponseStatus.EXPECTATION_FAILED;
    case INTERNAL_SERVER_ERROR:
        return HttpResponseStatus.INTERNAL_SERVER_ERROR;
    case NOT_IMPLEMENTED:
        return HttpResponseStatus.NOT_IMPLEMENTED;
    case BAD_GATEWAY:
        return HttpResponseStatus.BAD_GATEWAY;
    case SERVICE_UNAVAILABLE:
        return HttpResponseStatus.SERVICE_UNAVAILABLE;
    case GATEWAY_TIMEOUT:
        return HttpResponseStatus.GATEWAY_TIMEOUT;
    case HTTP_VERSION_NOT_SUPPORTED:
        return HttpResponseStatus.HTTP_VERSION_NOT_SUPPORTED;
    case CONTINUE:
        return HttpResponseStatus.CONTINUE;
    default:
        throw new RuntimeException(String.format("Status: %s not supported", status));
    }
}

From source file:org.robotbrains.support.web.server.netty.NettyStaticContentHandler.java

License:Apache License

@Override
public void handleWebRequest(ChannelHandlerContext ctx, HttpRequest request, Set<HttpCookie> cookiesToAdd)
        throws IOException {
    String url = request.getUri();
    String originalUrl = url;/* ww  w .ja  va2s.c  om*/

    // Strip off query parameters, if any, as we don't care.
    int pos = url.indexOf('?');
    if (pos != -1) {
        url = url.substring(0, pos);
    }

    int luriPrefixLength = uriPrefix.length();
    String filepath = URLDecoder.decode(url.substring(url.indexOf(uriPrefix) + luriPrefixLength),
            StandardCharsets.UTF_8.name());

    File file = new File(baseDir, filepath);

    // Refuse to process if the path wanders outside of the base directory.
    if (!allowLinks && !fileSupport.isParent(baseDir, file)) {
        HttpResponseStatus status = HttpResponseStatus.FORBIDDEN;
        parentHandler.getWebServer().getLog().warn(String.format(
                "HTTP [%s] %s --> (Path attempts to leave base directory)", status.code(), originalUrl));
        parentHandler.sendError(ctx, status);
        return;
    }

    RandomAccessFile raf;
    try {
        raf = new RandomAccessFile(file, "r");
    } catch (FileNotFoundException fnfe) {
        if (fallbackHandler != null) {
            fallbackHandler.handleWebRequest(ctx, request, cookiesToAdd);
        } else {
            HttpResponseStatus status = HttpResponseStatus.NOT_FOUND;
            parentHandler.getWebServer().getLog()
                    .warn(String.format("HTTP [%s] %s --> (File Not Found)", status.code(), originalUrl));
            parentHandler.sendError(ctx, status);
        }
        return;
    }
    long fileLength = raf.length();

    // Start with an initial OK response which will be modified as needed.
    HttpResponse response = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.OK);

    setMimeType(filepath, response);

    parentHandler.addHttpResponseHeaders(response, extraHttpContentHeaders);
    parentHandler.addHeaderIfNotExists(response, HttpHeaders.Names.ACCEPT_RANGES, HttpHeaders.Values.BYTES);

    if (cookiesToAdd != null) {

        addHeader(response, HttpHeaders.Names.SET_COOKIE, ServerCookieEncoder.STRICT
                .encode(Collections2.transform(cookiesToAdd, new Function<HttpCookie, Cookie>() {
                    @Override
                    public Cookie apply(HttpCookie cookie) {
                        return NettyHttpResponse.createNettyCookie(cookie);
                    }
                })));
    }

    RangeRequest rangeRequest = null;
    try {
        rangeRequest = parseRangeRequest(request, fileLength);
    } catch (Exception e) {
        try {
            HttpResponseStatus status = HttpResponseStatus.REQUESTED_RANGE_NOT_SATISFIABLE;
            parentHandler.getWebServer().getLog()
                    .error(String.format("[%s] HTTP %s --> %s", status.code(), originalUrl, e.getMessage()));
            response.setStatus(status);
            parentHandler.sendError(ctx, status);
        } finally {
            try {
                raf.close();
            } catch (Exception e1) {
                parentHandler.getWebServer().getLog().warn("Unable to close static content file", e1);
            }
        }
        return;
    }

    HttpResponseStatus status = HttpResponseStatus.OK;
    if (rangeRequest == null) {
        setContentLength(response, fileLength);
    } else {
        setContentLength(response, rangeRequest.getRangeLength());
        addHeader(response, HttpHeaders.Names.CONTENT_RANGE,
                CONTENT_RANGE_PREFIX + rangeRequest.begin + CONTENT_RANGE_RANGE_SEPARATOR + rangeRequest.end
                        + CONTENT_RANGE_RANGE_SIZE_SEPARATOR + fileLength);
        status = HttpResponseStatus.PARTIAL_CONTENT;
        response.setStatus(status);
    }

    Channel ch = ctx.channel();

    // Write the initial line and the header.
    ChannelFuture writeFuture = ch.write(response);

    // Write the content if there have been no errors and we are a GET request.
    if (HttpMethod.GET == request.getMethod()) {
        if (ch.pipeline().get(SslHandler.class) != null) {
            // Cannot use zero-copy with HTTPS.
            writeFuture = ch.write(new ChunkedFile(raf, 0, fileLength, COPY_CHUNK_SIZE));
        } else {
            // No encryption - use zero-copy.
            final FileRegion region = new DefaultFileRegion(raf.getChannel(),
                    rangeRequest != null ? rangeRequest.begin : 0,
                    rangeRequest != null ? rangeRequest.getRangeLength() : fileLength);
            writeFuture = ch.write(region);
            writeFuture.addListener(new ChannelProgressiveFutureListener() {
                @Override
                public void operationComplete(ChannelProgressiveFuture future) throws Exception {
                    region.release();
                }

                @Override
                public void operationProgressed(ChannelProgressiveFuture future, long progress, long total)
                        throws Exception {
                    // Do nothng
                }
            });
        }
    }

    // Decide whether to close the connection or not.
    if (!isKeepAlive(request)) {
        // Close the connection when the whole content is written out.
        writeFuture.addListener(ChannelFutureListener.CLOSE);
    }

    parentHandler.getWebServer().getLog()
            .trace(String.format("[%s] HTTP %s --> %s", status.code(), originalUrl, file.getPath()));
}