@PUT @Path("state") @Consumes(APPLICATION_JSON) @Produces(TEXT_PLAIN) public Response updateState(NodeState state) throws WebApplicationException { requireNonNull(state, "state is null"); switch (state) { case SHUTTING_DOWN: shutdownHandler.requestShutdown(); return Response.ok().build(); case ACTIVE: case INACTIVE: throw new WebApplicationException(Response .status(BAD_REQUEST) .type(MediaType.TEXT_PLAIN) .entity(format("Invalid state transition to %s", state)) .build()); default: return Response.status(BAD_REQUEST) .type(TEXT_PLAIN) .entity(format("Invalid state %s", state)) .build(); } }
@Override public Response toResponse(WebApplicationException exception) { // get the message and ensure it is not blank String message = exception.getMessage(); if (message == null) { message = StringUtils.EMPTY; } // format the message if (message.contains(EXCEPTION_SEPARATOR)) { message = StringUtils.substringAfter(message, EXCEPTION_SEPARATOR); } // get the response final Response response = exception.getResponse(); // log the error logger.info(String.format("%s. Returning %s response.", exception, response.getStatus())); if (logger.isDebugEnabled()) { logger.debug(StringUtils.EMPTY, exception); } // generate the response return Response.status(response.getStatus()).entity(message).type("text/plain").build(); }
public ErrorInfo(WebApplicationException exception) { this.message = exception.getMessage(); this.status = exception.getResponse().getStatus(); }
@Override public Response toResponse(WebApplicationException e) { final ApiError apiError = ApiError.create(e.getMessage()); return Response.fromResponse(e.getResponse()) .type(MediaType.APPLICATION_JSON_TYPE) .entity(apiError).build(); } }
private Response createResponse(final WebApplicationException exception) { final ErrorMessage errorMessage = new ErrorMessage(exception.getResponse().getStatus(), exception.getLocalizedMessage()); return Response.status(errorMessage.getCode()) .type(APPLICATION_JSON_TYPE) .entity(errorMessage) .build(); } }
@PUT @Path("/tasks/cleanuptasks/{taskType}") @ApiOperation("Clean up tasks for the given task type") public SuccessResponse cleanUpTasks( @ApiParam(value = "Task type", required = true) @PathParam("taskType") String taskType) { try { _pinotHelixTaskResourceManager.cleanUpTaskQueue(taskType); return new SuccessResponse("Successfully cleaned up tasks for task type: " + taskType); } catch (Exception e) { throw new WebApplicationException(e); } }
@GET @Path("/tasks/taskqueues") @ApiOperation("List all task queues") public Set<String> getTaskQueues() { try { return _pinotHelixTaskResourceManager.getTaskQueues(); } catch (Exception e) { throw new WebApplicationException(e); } }
@POST @Produces(MediaType.APPLICATION_JSON) @Path("query") @ApiOperation(value = "Querying pinot") @ApiResponses(value = {@ApiResponse(code = 200, message = "Query response"), @ApiResponse(code = 500, message = "Internal Server Error")}) public String processQueryPost(String query) { try { JsonNode requestJson = JsonUtils.stringToJsonNode(query); BrokerResponse brokerResponse = requestHandler.handleRequest(requestJson, null, new RequestStatistics()); return brokerResponse.toJsonString(); } catch (Exception e) { LOGGER.error("Caught exception while processing GET request", e); brokerMetrics.addMeteredGlobalValue(BrokerMeter.UNCAUGHT_GET_EXCEPTIONS, 1); throw new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR); } } }
@POST @Path("webapplication_noentity") public String testWebApplicationExceptionNoEntity(String s) { String[] tokens = s.split(":"); assert tokens.length == 2; int statusCode = Integer.valueOf(tokens[1]); Response r = Response.status(statusCode).build(); throw new WebApplicationException(r); }
@GET @Timed @Produces(MediaType.APPLICATION_JSON) public Map<String, String> naturalDateTester(@QueryParam("string") @NotEmpty String string) { try { return new NaturalDateParser().parse(string).asMap(); } catch (NaturalDateParser.DateNotParsableException e) { LOG.debug("Could not parse from natural date: " + string, e); throw new WebApplicationException(e, 422); } } }
private static WebApplicationException badRequest(String message) { throw new WebApplicationException(Response .status(Status.BAD_REQUEST) .type(MediaType.TEXT_PLAIN) .entity(message) .build()); }
@Produces("*/*") @Consumes("*/*") public static final class General extends JettisonArrayProvider { @Override protected boolean isSupported(MediaType m) { return m.getSubtype().endsWith("+json"); } }
@Override public Response toResponse(E exception) { // If we're dealing with a web exception, we can service certain types of request (like // redirection or server errors) better and also propagate properties of the inner response. if (exception instanceof WebApplicationException) { final Response response = ((WebApplicationException) exception).getResponse(); Response.Status.Family family = response.getStatusInfo().getFamily(); if (family.equals(Response.Status.Family.REDIRECTION)) { return response; } if (family.equals(Response.Status.Family.SERVER_ERROR)) { logException(exception); } return Response.fromResponse(response) .type(MediaType.APPLICATION_JSON_TYPE) .entity(new ErrorMessage(response.getStatus(), exception.getLocalizedMessage())) .build(); } // Else the thrown exception is a not a web exception, so the exception is most likely // unexpected. We'll create a unique id in the server error response that is also logged for // correlation final long id = logException(exception); return Response.status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()) .type(MediaType.APPLICATION_JSON_TYPE) .entity(new ErrorMessage(formatErrorMessage(id, exception))) .build(); }
@Override public Response toResponse(WebApplicationException exception) { logger.error(String.format("Error %s url: '%s'", exception.getClass().getSimpleName(), uriInfo.getPath()), exception); Response response = exception.getResponse(); this.code = Code.forValue(response.getStatus()); Map<String, Object> entityMap = new LinkedHashMap<>(); entityMap.put("instance", host); entityMap.put("code", Optional.of(code.toString()).orElse(null)); entityMap.put("message", exception.getCause()); entityMap.put("retryable", false); return Response.status(response.getStatus()).entity(entityMap).build(); }
@Override public Response toResponse(Exception e) { if (e instanceof WebApplicationException) { WebApplicationException exception = (WebApplicationException) e; String message; if (exception.getCause() != null) { message = Log.exceptionStack(exception.getCause()); } else { message = Log.exceptionStack(exception); } return Response.fromResponse(exception.getResponse()).entity(message).build(); } else { return Response.status(Response.Status.BAD_REQUEST).entity(Log.exceptionStack(e)).build(); } }
private Response proxyJsonResponse(String nodeId, String workerPath) { Set<Node> nodes = nodeManager.getNodes(NodeState.ACTIVE); Node node = nodes.stream() .filter(n -> n.getNodeIdentifier().equals(nodeId)) .findFirst() .orElseThrow(() -> new WebApplicationException(NOT_FOUND)); Request request = prepareGet() .setUri(uriBuilderFrom(node.getHttpUri()) .appendPath(workerPath) .build()) .build(); InputStream responseStream = httpClient.execute(request, new StreamingJsonResponseHandler()); return Response.ok(responseStream, APPLICATION_JSON_TYPE).build(); }
/** * Get the status of the error response. * * @return Response status code. */ public Response.Status getStatus() { return Response.Status.fromStatusCode(super.getResponse().getStatus()); }
private static String urlDecode(String value) { try { return URLDecoder.decode(value, "UTF-8"); } catch (UnsupportedEncodingException e) { throw new WebApplicationException(BAD_REQUEST); } } }