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

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

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

Introduction

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

Prototype

HttpResponseStatus NOT_ACCEPTABLE

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

Click Source Link

Document

406 Not Acceptable

Usage

From source file:com.example.grpc.server.PrometheusServer.java

License:Apache License

public void start() {
    final ServerBootstrap bootstrap = new ServerBootstrap();

    bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
            .handler(new LoggingHandler(LogLevel.INFO)).childHandler(new ChannelInitializer<SocketChannel>() {
                @Override//from  w  ww.j  a  va2 s. c  om
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    ChannelPipeline pipeline = socketChannel.pipeline();
                    pipeline.addLast("decoder", new HttpRequestDecoder());
                    pipeline.addLast("encoder", new HttpResponseEncoder());
                    pipeline.addLast("prometheus", new SimpleChannelInboundHandler<Object>() {
                        @Override
                        protected void channelRead0(ChannelHandlerContext channelHandlerContext, Object o)
                                throws Exception {
                            if (!(o instanceof HttpRequest)) {
                                return;
                            }

                            HttpRequest request = (HttpRequest) o;

                            if (!"/metrics".equals(request.uri())) {
                                final FullHttpResponse response = new DefaultFullHttpResponse(
                                        HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND);
                                channelHandlerContext.writeAndFlush(response)
                                        .addListener(ChannelFutureListener.CLOSE);
                                return;
                            }

                            if (!HttpMethod.GET.equals(request.method())) {
                                final FullHttpResponse response = new DefaultFullHttpResponse(
                                        HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_ACCEPTABLE);
                                channelHandlerContext.writeAndFlush(response)
                                        .addListener(ChannelFutureListener.CLOSE);
                                return;
                            }

                            ByteBuf buf = Unpooled.buffer();
                            ByteBufOutputStream os = new ByteBufOutputStream(buf);
                            OutputStreamWriter writer = new OutputStreamWriter(os);
                            TextFormat.write004(writer, registry.metricFamilySamples());
                            writer.close();
                            os.close();

                            final FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
                                    HttpResponseStatus.OK, buf);
                            response.headers().set(HttpHeaderNames.CONTENT_TYPE, TextFormat.CONTENT_TYPE_004);
                            channelHandlerContext.writeAndFlush(response)
                                    .addListener(ChannelFutureListener.CLOSE);
                        }
                    });

                }
            });

    try {
        this.channel = bootstrap.bind(this.port).sync().channel();
    } catch (InterruptedException e) {
        // do nothing
    }
}

From source file:com.linecorp.armeria.server.thrift.ThriftServiceCodec.java

License:Apache License

private SerializationFormat validateRequestAndDetermineSerializationFormat(Object originalRequest)
        throws InvalidHttpRequestException {
    if (!(originalRequest instanceof HttpRequest)) {
        return defaultSerializationFormat;
    }// www  . ja  v a  2 s  .c o  m
    final SerializationFormat serializationFormat;
    HttpRequest httpRequest = (HttpRequest) originalRequest;
    if (httpRequest.method() != HttpMethod.POST) {
        throw new InvalidHttpRequestException(HttpResponseStatus.METHOD_NOT_ALLOWED,
                HTTP_METHOD_NOT_ALLOWED_EXCEPTION);
    }

    final String contentTypeHeader = httpRequest.headers().get(HttpHeaderNames.CONTENT_TYPE);
    if (contentTypeHeader != null) {
        serializationFormat = SerializationFormat.fromMimeType(contentTypeHeader)
                .orElse(defaultSerializationFormat);
        if (!allowedSerializationFormats.contains(serializationFormat)) {
            throw new InvalidHttpRequestException(HttpResponseStatus.UNSUPPORTED_MEDIA_TYPE,
                    THRIFT_PROTOCOL_NOT_SUPPORTED);
        }
    } else {
        serializationFormat = defaultSerializationFormat;
    }

    final String acceptHeader = httpRequest.headers().get(HttpHeaderNames.ACCEPT);
    if (acceptHeader != null) {
        // If accept header is present, make sure it is sane. Currently, we do not support accept
        // headers with a different format than the content type header.
        SerializationFormat outputSerializationFormat = SerializationFormat.fromMimeType(acceptHeader)
                .orElse(serializationFormat);
        if (outputSerializationFormat != serializationFormat) {
            throw new InvalidHttpRequestException(HttpResponseStatus.NOT_ACCEPTABLE,
                    ACCEPT_THRIFT_PROTOCOL_MUST_MATCH_CONTENT_TYPE);
        }
    }
    return serializationFormat;
}

From source file:io.liveoak.container.protocols.http.HttpResourceRequestDecoder.java

License:Open Source License

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    if (cause instanceof DecoderException) {
        Throwable rootCause = cause.getCause();
        if (rootCause instanceof UnsupportedMediaTypeException) {
            DefaultFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
                    HttpResponseStatus.NOT_ACCEPTABLE);
            response.headers().add(HttpHeaders.Names.CONTENT_LENGTH, 0);
            ctx.writeAndFlush(response);
            return;
        }//from  w w w .j  a va  2s.  co  m
    }
    super.exceptionCaught(ctx, cause);
}

From source file:io.liveoak.container.protocols.http.HttpResourceResponseEncoder.java

License:Open Source License

@Override
protected void encode(ChannelHandlerContext ctx, DefaultResourceResponse msg, List<Object> out)
        throws Exception {

    int responseStatusCode = 0;
    String responseMessage = null;
    HttpHeaders responseHeaders = new DefaultHttpHeaders();

    boolean shouldEncodeState = false;
    boolean shouldCheckForHtmlApp = true;
    switch (msg.responseType()) {
    case CREATED:
        responseStatusCode = HttpResponseStatus.CREATED.code();
        responseMessage = HttpResponseStatus.CREATED.reasonPhrase();
        shouldEncodeState = true;//from w w w.  j av a  2 s  .  com
        break;
    case READ:
        responseStatusCode = HttpResponseStatus.OK.code();
        responseMessage = HttpResponseStatus.OK.reasonPhrase();
        shouldEncodeState = true;
        break;
    case UPDATED:
        responseStatusCode = HttpResponseStatus.OK.code();
        responseMessage = HttpResponseStatus.OK.reasonPhrase();
        shouldEncodeState = true;
        break;
    case DELETED:
        responseStatusCode = HttpResponseStatus.OK.code();
        responseMessage = HttpResponseStatus.OK.reasonPhrase();
        shouldEncodeState = true;
        break;
    case ERROR:
        if (msg instanceof ResourceErrorResponse) {
            shouldEncodeState = true;
            shouldCheckForHtmlApp = false;
            switch (((DefaultResourceErrorResponse) msg).errorType()) {
            case NOT_AUTHORIZED:
                responseStatusCode = HttpResponseStatus.UNAUTHORIZED.code();
                responseMessage = HttpResponseStatus.UNAUTHORIZED.reasonPhrase();
                break;
            case FORBIDDEN:
                responseStatusCode = HttpResponseStatus.FORBIDDEN.code();
                responseMessage = HttpResponseStatus.FORBIDDEN.reasonPhrase();
                break;
            case NOT_ACCEPTABLE:
                responseStatusCode = HttpResponseStatus.NOT_ACCEPTABLE.code();
                responseMessage = HttpResponseStatus.NOT_ACCEPTABLE.reasonPhrase();
                break;
            case NO_SUCH_RESOURCE:
                responseStatusCode = HttpResponseStatus.NOT_FOUND.code();
                responseMessage = HttpResponseStatus.NOT_FOUND.reasonPhrase();
                break;
            case RESOURCE_ALREADY_EXISTS:
                responseStatusCode = HttpResponseStatus.NOT_ACCEPTABLE.code();
                responseMessage = HttpResponseStatus.NOT_ACCEPTABLE.reasonPhrase();
                break;
            case CREATE_NOT_SUPPORTED:
                responseStatusCode = HttpResponseStatus.METHOD_NOT_ALLOWED.code();
                responseMessage = "Create not supported";
                break;
            case READ_NOT_SUPPORTED:
                responseStatusCode = HttpResponseStatus.METHOD_NOT_ALLOWED.code();
                responseMessage = "Read not supported";
                break;
            case UPDATE_NOT_SUPPORTED:
                responseStatusCode = HttpResponseStatus.METHOD_NOT_ALLOWED.code();
                responseMessage = "UpdateStep not supported";
                break;
            case DELETE_NOT_SUPPORTED:
                responseStatusCode = HttpResponseStatus.METHOD_NOT_ALLOWED.code();
                responseMessage = "Delete not supported";
                break;
            case INTERNAL_ERROR:
                responseStatusCode = HttpResponseStatus.INTERNAL_SERVER_ERROR.code();
                responseMessage = HttpResponseStatus.INTERNAL_SERVER_ERROR.reasonPhrase();
                break;
            }

            //TODO: add content values here to return proper error messages to the client
            // eg unique error id, short error message, link to page with more information, etc...
            //response.content().writeBytes(...)

        }
        break;
    case MOVED:
        if (msg instanceof ResourceMovedResponse) {
            ResourceMovedResponse resourceMovedResponse = (ResourceMovedResponse) msg;

            switch (resourceMovedResponse.movedType()) {
            case MOVED_PERMANENTLY:
                responseStatusCode = HttpResponseStatus.MOVED_PERMANENTLY.code();
                responseMessage = HttpResponseStatus.MOVED_PERMANENTLY.reasonPhrase();
                break;
            case MOVED_TEMPORARILY:
                responseStatusCode = HttpResponseStatus.FOUND.code();
                responseMessage = HttpResponseStatus.FOUND.reasonPhrase();
                break;
            }

            Integer maxAge = resourceMovedResponse.maxAge();
            if (maxAge != null) {
                responseHeaders.add(HttpHeaders.Names.CACHE_CONTROL, "max-age=" + maxAge);
            }

            responseHeaders.add(HttpHeaders.Names.LOCATION, ((ResourceMovedResponse) msg).redirectURL());
        }
        break;
    }

    DefaultHttpResponse response;
    HttpResponseStatus responseStatus;

    EncodingResult encodingResult = null;
    if (shouldEncodeState) {
        MediaTypeMatcher matcher = msg.inReplyTo().mediaTypeMatcher();

        if (shouldCheckForHtmlApp) {
            Application app = msg.inReplyTo().requestContext().application();
            if (app != null && app instanceof InternalApplication) {
                ResourcePath htmlAppPath = ((InternalApplication) app).htmlApplicationResourcePath();
                if ((!(msg.resource() instanceof BinaryResource)) && (htmlAppPath != null)) {
                    MediaType bestMatch = matcher.findBestMatch(this.codecManager.mediaTypes());
                    if (bestMatch == MediaType.HTML) {
                        // HTML was requested and we have an HTML app
                        ResourceRequest htmlAppRequest = new DefaultResourceRequest.Builder(RequestType.READ,
                                htmlAppPath).mediaTypeMatcher(msg.inReplyTo().mediaTypeMatcher())
                                        .requestAttributes(msg.inReplyTo().requestContext().requestAttributes())
                                        .build();
                        ctx.channel().pipeline().fireChannelRead(htmlAppRequest);
                        return;
                    }
                }
            }
        }

        try {
            encodingResult = encodeState(msg.inReplyTo().requestContext(), matcher, msg);
        } catch (IncompatibleMediaTypeException e) {
            log.error("Incompatible media type", e);
            responseStatus = new HttpResponseStatus(HttpResponseStatus.NOT_ACCEPTABLE.code(), e.getMessage());
            response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, responseStatus);
            response.headers().add(HttpHeaders.Names.CONTENT_LENGTH, 0);
            out.add(response);
            return;
        } catch (Throwable e) {
            log.error("Could not encode HTTP response", e);
            responseStatus = new HttpResponseStatus(HttpResponseStatus.INTERNAL_SERVER_ERROR.code(),
                    HttpResponseStatus.INTERNAL_SERVER_ERROR.reasonPhrase());
            response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, responseStatus);
            response.headers().add(HttpHeaders.Names.CONTENT_LENGTH, 0);
            out.add(response);
            return;
        }
    }

    responseStatus = new HttpResponseStatus(responseStatusCode, responseMessage);

    if (encodingResult != null) {

        if (msg.resource() instanceof BinaryResource) {
            BinaryResource bin = (BinaryResource) msg.resource();
            if (bin.contentLength() == 0) {
                response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, responseStatus);
                response.headers().add(HttpHeaders.Names.CONTENT_LENGTH, 0);
            } else {
                response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, responseStatus);
                response.headers().add(HttpHeaders.Names.CONTENT_LENGTH, bin.contentLength());
                response.headers().add(HttpHeaders.Names.LOCATION, msg.resource().uri().toString());
                response.headers().add(HttpHeaders.Names.CONTENT_TYPE, bin.mediaType());

                final HttpResponse res = response;
                bin.readContent(msg.inReplyTo().requestContext(), new BinaryContentSink() {
                    {
                        ctx.write(res);
                    }

                    @Override
                    public void close() {
                        ctx.writeAndFlush(new DefaultLastHttpContent(Unpooled.EMPTY_BUFFER));
                        ctx.pipeline().fireUserEventTriggered(new RequestCompleteEvent(msg.requestId()));
                    }

                    @Override
                    public void accept(ByteBuf byteBuf) {
                        ctx.write(new DefaultHttpContent(byteBuf));
                    }
                });
                return;
            }
        } else {
            ByteBuf content = encodingResult.encoded();

            response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, responseStatus, content);
            response.headers().add(HttpHeaders.Names.CONTENT_LENGTH, content.readableBytes());
            if (msg.resource() != null) {
                response.headers().add(HttpHeaders.Names.LOCATION, msg.resource().uri().toString());
            } else {
                response.headers().add(HttpHeaders.Names.LOCATION, msg.inReplyTo().resourcePath().toString());
            }
            response.headers().add(HttpHeaders.Names.CONTENT_TYPE, encodingResult.mediaType());
        }
    } else {
        response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, responseStatus);
        response.headers().add(HttpHeaders.Names.CONTENT_LENGTH, 0);
    }

    response.headers().add(responseHeaders);

    out.add(response);
    ctx.fireUserEventTriggered(new RequestCompleteEvent(msg.requestId()));
}

From source file:org.iotivity.cloud.base.protocols.http.HCProxyProcessor.java

License:Open Source License

private HttpResponseStatus getHttpResponseStatus(ResponseStatus coapResponseStatus, boolean isPayload) {

    HttpResponseStatus httpStatusCode = HttpResponseStatus.NOT_IMPLEMENTED;

    if (coapResponseStatus == ResponseStatus.CREATED) {

        httpStatusCode = HttpResponseStatus.CREATED;

    } else if (coapResponseStatus == ResponseStatus.DELETED || coapResponseStatus == ResponseStatus.CHANGED
            || coapResponseStatus == ResponseStatus.CONTENT) {

        if (isPayload) {
            httpStatusCode = HttpResponseStatus.OK;
        } else {//from  ww w  . ja  va  2s .com
            httpStatusCode = HttpResponseStatus.NO_CONTENT;
        }

    } else if (coapResponseStatus == ResponseStatus.VALID) {

        if (isPayload) {
            httpStatusCode = HttpResponseStatus.OK;
        } else {
            httpStatusCode = HttpResponseStatus.NOT_MODIFIED;
        }

    } else if (coapResponseStatus == ResponseStatus.UNAUTHORIZED
            || coapResponseStatus == ResponseStatus.FORBIDDEN) {

        httpStatusCode = HttpResponseStatus.FORBIDDEN;

    } else if (coapResponseStatus == ResponseStatus.BAD_REQUEST
            || coapResponseStatus == ResponseStatus.BAD_OPTION) {

        httpStatusCode = HttpResponseStatus.BAD_REQUEST;

    } else if (coapResponseStatus == ResponseStatus.METHOD_NOT_ALLOWED) {

        // The HC Proxy should return a HTTP reason-phrase
        // in the HTTP status line that starts with the string
        // "CoAP server returned 4.05"
        // in order to facilitate troubleshooting.
        httpStatusCode = new HttpResponseStatus(400, "CoAP server returned 4.05");

    } else if (coapResponseStatus == ResponseStatus.NOT_ACCEPTABLE) {

        httpStatusCode = HttpResponseStatus.NOT_ACCEPTABLE;

    } else if (coapResponseStatus == ResponseStatus.PRECONDITION_FAILED) {

        httpStatusCode = HttpResponseStatus.PRECONDITION_FAILED;

    } else if (coapResponseStatus == ResponseStatus.UNSUPPORTED_CONTENT_FORMAT) {

        httpStatusCode = HttpResponseStatus.UNSUPPORTED_MEDIA_TYPE;

    } else if (coapResponseStatus == ResponseStatus.BAD_GATEWAY
            || coapResponseStatus == ResponseStatus.PROXY_NOT_SUPPORTED) {

        httpStatusCode = HttpResponseStatus.BAD_GATEWAY;

    } else if (coapResponseStatus == ResponseStatus.SERVICE_UNAVAILABLE) {

        httpStatusCode = HttpResponseStatus.SERVICE_UNAVAILABLE;

    } else if (coapResponseStatus == ResponseStatus.GATEWAY_TIMEOUT) {

        httpStatusCode = HttpResponseStatus.GATEWAY_TIMEOUT;

    } else if (coapResponseStatus == ResponseStatus.NOT_FOUND) {

        httpStatusCode = HttpResponseStatus.NOT_FOUND;

    } else if (coapResponseStatus == ResponseStatus.INTERNAL_SERVER_ERROR) {

        httpStatusCode = HttpResponseStatus.INTERNAL_SERVER_ERROR;
    }

    return httpStatusCode;
}

From source file:org.jpos.qrest.participant.Q2Info.java

License:Open Source License

@Override
public int prepare(long id, Serializable context) {
    Context ctx = (Context) context;
    FullHttpRequest request = (FullHttpRequest) ctx.get(REQUEST);
    QueryStringDecoder decoder = new QueryStringDecoder(request.uri());
    Map<String, Object> response = null;
    Optional<Route<Map<String, Object>>> route = routes.stream().filter(rr -> rr.matches(decoder.uri()))
            .findFirst();/*  w w  w  .  jav a  2 s  . co m*/
    String path = URI.create(decoder.uri()).getPath();

    HttpResponseStatus status = HttpResponseStatus.NOT_FOUND;
    if (route.isPresent()) {
        if (route.get().isValid(path)) {
            response = new LinkedHashMap<>();
            response.putAll(route.get().apply(route.get(), path));
            status = HttpResponseStatus.OK;
        }
    } else {
        response = new LinkedHashMap<>();
        for (Route<Map<String, Object>> r : routes) {
            if (!r.hasPathParams())
                response.putAll(r.apply(r, path));
        }
        status = HttpResponseStatus.OK;
    }
    if (response != null && response.containsKey("error")) {
        status = HttpResponseStatus.NOT_ACCEPTABLE;
    }
    ctx.put(RESPONSE, response != null ? new Response(status, response)
            : new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status));
    return PREPARED | NO_JOIN | READONLY;
}

From source file:org.jspare.forvertx.web.handling.Handling.java

License:Apache License

/**
 * Not acceptable.
 */
public void notAcceptable() {

    status(HttpResponseStatus.NOT_ACCEPTABLE);
    end();
}

From source file:org.nosceon.titanite.Response.java

License:Apache License

public static Response notAcceptable() {
    return new Response(HttpResponseStatus.NOT_ACCEPTABLE);
}

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

License:Apache License

private HttpResponseStatus fromStatus(Response.Status status) {
    switch (status) {
    case OK://www  .j  a v  a 2  s.  c o m
        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.waarp.gateway.kernel.http.HttpRequestHandler.java

License:Open Source License

/**
 * Method that get post data/* w w  w . j ava  2 s .c  o  m*/
 * 
 * @param ctx
 * @throws HttpIncorrectRequestException
 */
protected void post(ChannelHandlerContext ctx) throws HttpIncorrectRequestException {
    try {
        decoder = new HttpPostRequestDecoder(HttpBusinessFactory.factory, request);
    } catch (ErrorDataDecoderException e1) {
        status = HttpResponseStatus.NOT_ACCEPTABLE;
        throw new HttpIncorrectRequestException(e1);
    } catch (Exception e1) {
        // GETDOWNLOAD Method: should not try to create a HttpPostRequestDecoder
        // So OK but stop here
        status = HttpResponseStatus.NOT_ACCEPTABLE;
        throw new HttpIncorrectRequestException(e1);
    }

    if (request instanceof FullHttpRequest) {
        // Not chunk version
        readHttpDataAllReceive(ctx);
        finalData(ctx);
        writeSimplePage(ctx);
        clean();
    }
}