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

Introduction

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

Prototype

HttpResponseStatus MULTI_STATUS

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

Click Source Link

Document

207 Multi-Status (WebDAV, RFC2518)

Usage

From source file:com.rackspacecloud.blueflood.inputs.handlers.HttpAggregatedMultiIngestionHandler.java

License:Apache License

@Override
public void handle(ChannelHandlerContext ctx, FullHttpRequest request) {

    Tracker.getInstance().track(request);

    requestCount.inc();//from   ww w.j  a  va 2s.  c  om

    final Timer.Context timerContext = handlerTimer.time();
    long ingestTime = clock.now().getMillis();

    // this is all JSON.
    String body = null;
    try {
        body = request.content().toString(Constants.DEFAULT_CHARSET);
        List<AggregatedPayload> bundleList = createBundleList(body);

        if (bundleList.size() > 0) {
            // has aggregated metric bundle in body
            // convert and add metric bundle to MetricsCollection if valid
            MetricsCollection collection = new MetricsCollection();
            List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>();

            // for each metric bundle
            for (AggregatedPayload bundle : bundleList) {
                // validate, convert, and add to collection
                List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors();
                if (bundleValidationErrors.isEmpty()) {
                    // no validation error, add to collection
                    collection.add(PreaggregateConversions.buildMetricsCollection(bundle));
                } else {
                    // failed validation, add to error
                    errors.addAll(bundleValidationErrors);
                }

                if (bundle.hasDelayedMetrics(ingestTime)) {
                    Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(),
                            bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames());
                    bundle.markDelayMetricsReceived(ingestTime);
                }
            }

            // if has validation errors and no valid metrics
            if (!errors.isEmpty() && collection.size() == 0) {
                // return BAD_REQUEST and error
                DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST);
                return;
            }

            // process valid metrics in collection
            ListenableFuture<List<Boolean>> futures = processor.apply(collection);
            List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit());
            for (Boolean persisted : persisteds) {
                if (!persisted) {
                    DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data",
                            HttpResponseStatus.INTERNAL_SERVER_ERROR);
                    return;
                }
            }

            // return OK or MULTI_STATUS response depending if there were validation errors
            if (errors.isEmpty()) {
                // no validation error, response OK
                DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK);
                return;
            } else {
                // has some validation errors, response MULTI_STATUS
                DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS);
                return;
            }

        } else {
            // no aggregated metric bundles in body, response OK
            DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST);
            return;
        }
    } catch (JsonParseException ex) {
        log.debug(String.format("BAD JSON: %s", body));
        log.error(ex.getMessage(), ex);
        DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST);
    } catch (InvalidDataException ex) {
        log.debug(String.format("Invalid request body: %s", body));
        log.error(ex.getMessage(), ex);
        DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST);
    } catch (TimeoutException ex) {
        DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics",
                HttpResponseStatus.ACCEPTED);
    } catch (Exception ex) {
        log.debug(String.format("BAD JSON: %s", body));
        log.error("Other exception while trying to parse content", ex);
        DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data",
                HttpResponseStatus.INTERNAL_SERVER_ERROR);
    } finally {
        timerContext.stop();
        requestCount.dec();
    }

}

---

From source file:com.rackspacecloud.blueflood.inputs.handlers.HttpMetricsIngestionHandler.java

License:Apache License

@Override
public void handle(ChannelHandlerContext ctx, FullHttpRequest request) {
    try {//ww w  . ja v a2 s .  c  o m

        Tracker.getInstance().track(request);
        requestCount.inc();

        final String tenantId = request.headers().get("tenantId");

        JSONMetricsContainer jsonMetricsContainer;
        List<Metric> validMetrics;

        final Timer.Context jsonTimerContext = jsonTimer.time();

        final String body = request.content().toString(Constants.DEFAULT_CHARSET);
        try {
            jsonMetricsContainer = createContainer(body, tenantId);

            if (jsonMetricsContainer.areDelayedMetricsPresent()) {
                Tracker.getInstance().trackDelayedMetricsTenant(tenantId,
                        jsonMetricsContainer.getDelayedMetrics());
            }

            validMetrics = jsonMetricsContainer.getValidMetrics();
            forceTTLsIfConfigured(validMetrics);

        } catch (JsonParseException e) {
            log.warn("Exception parsing content", e);
            DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content",
                    HttpResponseStatus.BAD_REQUEST);
            return;
        } catch (JsonMappingException e) {
            log.warn("Exception parsing content", e);
            DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content",
                    HttpResponseStatus.BAD_REQUEST);
            return;
        } catch (InvalidDataException ex) {
            // todo: we should measure these. if they spike, we track down the bad client.
            // this is strictly a client problem. Something wasn't right (data out of range, etc.)
            log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage());
            DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(),
                    HttpResponseStatus.BAD_REQUEST);
            return;
        } catch (IOException e) {
            log.warn("IO Exception parsing content", e);
            DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content",
                    HttpResponseStatus.BAD_REQUEST);
            return;
        } catch (Exception e) {
            log.warn("Other exception while trying to parse content", e);
            DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content",
                    HttpResponseStatus.INTERNAL_SERVER_ERROR);
            return;
        } finally {
            jsonTimerContext.stop();
        }

        List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors();

        // If no valid metrics are present, return error response
        if (validMetrics.isEmpty()) {
            log.warn(ctx.channel().remoteAddress() + " No valid metrics");

            if (validationErrors.isEmpty()) {
                DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics",
                        HttpResponseStatus.BAD_REQUEST);
            } else {
                DefaultHandler.sendErrorResponse(ctx, request, validationErrors,
                        HttpResponseStatus.BAD_REQUEST);
            }
            return;
        }

        final MetricsCollection collection = new MetricsCollection();
        collection.add(new ArrayList<IMetric>(validMetrics));
        final Timer.Context persistingTimerContext = persistingTimer.time();
        try {
            ListenableFuture<List<Boolean>> futures = processor.apply(collection);
            List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit());
            for (Boolean persisted : persisteds) {
                if (!persisted) {
                    log.warn("Trouble persisting metrics:");
                    log.warn(String.format("%s", Arrays.toString(validMetrics.toArray())));
                    DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics",
                            HttpResponseStatus.INTERNAL_SERVER_ERROR);
                    return;
                }
            }

            // after processing metrics, return either OK or MULTI_STATUS depending on number of valid metrics
            if (!validationErrors.isEmpty()) {
                // has some validation errors, return MULTI_STATUS
                DefaultHandler.sendErrorResponse(ctx, request, validationErrors,
                        HttpResponseStatus.MULTI_STATUS);
            } else {
                // no validation error, return OK
                DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK);
            }

        } catch (TimeoutException e) {
            DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics",
                    HttpResponseStatus.ACCEPTED);
        } catch (Exception e) {
            log.error("Exception persisting metrics", e);
            DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics",
                    HttpResponseStatus.INTERNAL_SERVER_ERROR);
        } finally {
            persistingTimerContext.stop();
        }
    } finally {
        requestCount.dec();
    }
}

---