How to use

Response

in

javax.ws.rs.core

  @GET
  @Path("coordinator")
  @Produces(TEXT_PLAIN)
  public Response getServerCoordinator()
  {
    if (coordinator) {
      return Response.ok().build();
    }
    // return 404 to allow load balancers to only send traffic to the coordinator
    return Response.status(Response.Status.NOT_FOUND).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();
  }
}

@GET
@Produces({MediaType.APPLICATION_JSON, SmileMediaTypes.APPLICATION_JACKSON_SMILE})
public Response getAll()
{
 try {
  return handler.handleGETAll();
 }
 catch (Exception e) {
  LOG.error(e, "Exception in handling GETAll request");
  return Response.serverError().entity(ServletResourceUtils.sanitizeException(e)).build();
 }
}

@DELETE
@Path("{queryId}/{token}")
@Produces(MediaType.APPLICATION_JSON)
public Response cancelQuery(@PathParam("queryId") QueryId queryId,
    @PathParam("token") long token)
{
  Query query = queries.get(queryId);
  if (query == null) {
    return Response.status(Status.NOT_FOUND).build();
  }
  query.cancel();
  return Response.noContent().build();
}

@POST
@Path("/assignTask")
@Consumes({MediaType.APPLICATION_JSON, SmileMediaTypes.APPLICATION_JACKSON_SMILE})
public Response assignTask(Task task)
{
 try {
  workerTaskMonitor.assignTask(task);
  return Response.ok().build();
 }
 catch (RuntimeException ex) {
  return Response.serverError().entity(ex.getMessage()).build();
 }
}

@DELETE
@Path("/v1/proxy")
@Produces(APPLICATION_JSON)
public void cancelQuery(
    @QueryParam("uri") String uri,
    @QueryParam("hmac") String hash,
    @Context HttpServletRequest servletRequest,
    @Suspended AsyncResponse asyncResponse)
{
  if (!hmac.hashString(uri, UTF_8).equals(HashCode.fromString(hash))) {
    throw badRequest(FORBIDDEN, "Failed to validate HMAC of URI");
  }
  Request.Builder request = prepareDelete().setUri(URI.create(uri));
  performRequest(servletRequest, asyncResponse, request, response -> responseWithHeaders(noContent(), response));
}

@SuppressWarnings({"ConstantConditions"})
private int getNumSubTasks(Function<SinglePhaseParallelIndexingProgress, Integer> func)
{
 final Response response = task.getProgress(newRequest());
 Assert.assertEquals(200, response.getStatus());
 return func.apply((SinglePhaseParallelIndexingProgress) response.getEntity());
}

@Override
public final Response handleGET(String id)
{
 try {
  final Object returnObj = get(id);
  if (returnObj == null) {
   return Response.status(Response.Status.NOT_FOUND).build();
  } else {
   return Response.ok(returnObj).build();
  }
 }
 catch (Exception e) {
  LOG.error(e, "Error handling get request for [%s]", id);
  return Response.serverError().entity(ServletResourceUtils.sanitizeException(e)).build();
 }
}

@PUT
@RequiresPermissions(value = {RestPermissions.LDAPGROUPS_EDIT, RestPermissions.LDAP_EDIT}, logical = OR)
@ApiOperation(value = "Update the LDAP group to Graylog role mapping", notes = "Corresponds directly to the output of GET /system/ldap/settings/groups")
@Path("/settings/groups")
@Consumes(MediaType.APPLICATION_JSON)
@AuditEvent(type = AuditEventTypes.LDAP_GROUP_MAPPING_UPDATE)
public Response updateGroupMappingSettings(@ApiParam(name = "JSON body", required = true, value = "A hash in which the keys are the LDAP group names and values is the Graylog role name.")
                @NotNull Map<String, String> groupMapping) throws ValidationException {
  final LdapSettings ldapSettings = firstNonNull(ldapSettingsService.load(), ldapSettingsFactory.createEmpty());
  ldapSettings.setGroupMapping(groupMapping);
  ldapSettingsService.save(ldapSettings);
  return Response.noContent().build();
}

  protected Response handleConstraintViolationException(ConstraintViolationException cve) {
    ViolationReport report = new ViolationReport();
    for (ConstraintViolation cv : cve.getConstraintViolations()) {
      report.addConstraintViolation(new RestConstraintViolation(
          cv.getPropertyPath().toString(),
          cv.getMessage(),
          cv.getInvalidValue() == null ? "null" : cv.getInvalidValue().toString()));
    }
    // TODO for now just do xml output
    return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(report).type(ContentType.TEXT_XML_UTF_8).build();
  }
}

private <T> RestResponse<T> getRequest(final String path, final Class<T> type) {
 try (Response response = client.target(serverAddress)
   .path(path)
   .request(MediaType.APPLICATION_JSON_TYPE)
   .get()) {
  return response.getStatus() == Response.Status.OK.getStatusCode()
    ? RestResponse.successful(response.readEntity(type))
    : createErrorResponse(path, response);
 } catch (final Exception e) {
  throw new KsqlRestClientException("Error issuing GET to KSQL server. path:" + path, e);
 }
}

@Override
public EurekaHttpResponse<ReplicationListResponse> submitBatchUpdates(ReplicationList replicationList) {
  Response response = null;
  try {
    response = jerseyClient.target(serviceUrl)
        .path(PeerEurekaNode.BATCH_URL_PATH)
        .request(MediaType.APPLICATION_JSON_TYPE)
        .post(Entity.json(replicationList));
    if (!isSuccess(response.getStatus())) {
      return anEurekaHttpResponse(response.getStatus(), ReplicationListResponse.class).build();
    }
    ReplicationListResponse batchResponse = response.readEntity(ReplicationListResponse.class);
    return anEurekaHttpResponse(response.getStatus(), batchResponse).type(MediaType.APPLICATION_JSON_TYPE).build();
  } finally {
    if (response != null) {
      response.close();
    }
  }
}

@Test
public void testMissingProducerSequence() throws IOException
{
 setUpRequestExpectations("producer", null);
 final InputStream inputStream = IOUtils.toInputStream(inputRow, StandardCharsets.UTF_8);
 final Response response = firehose.addAll(inputStream, req);
 Assert.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
 inputStream.close();
 EasyMock.verify(req);
 firehose.close();
}

@Test
public void testGetTasksNegativeState()
{
 EasyMock.replay(taskRunner, taskMaster, taskStorageQueryAdapter, indexerMetadataStorageAdapter, req);
 Object responseObject = overlordResource
   .getTasks("blah", "ds_test", null, null, null, req)
   .getEntity();
 Assert.assertEquals(
   "Invalid state : blah, valid values are: [pending, waiting, running, complete]",
   responseObject.toString()
 );
}

@Override
public Response toResponse(WebApplicationException exception) {
  LOGGER.error("Template Error", exception);
  return Response.serverError()
      .type(MediaType.TEXT_HTML_TYPE)
      .entity(TEMPLATE_ERROR_MSG)
      .build();
}

public RestResponse<KsqlEntityList> makeKsqlRequest(final String ksql) {
 final KsqlRequest jsonRequest = new KsqlRequest(ksql, localProperties.toMap(), null);
 return postRequest("ksql", jsonRequest, Optional.empty(), true,
   r -> r.readEntity(KsqlEntityList.class));
}

  @Override
  public Response toResponse(EmptyOptionalException exception) {
    return Response.noContent().build();
  }
}

@Test
public void testExceptionalHandleAll()
{
 shouldFail.set(true);
 final Response response = abstractListenerHandler.handleGETAll();
 Assert.assertEquals(500, response.getStatus());
 Assert.assertEquals(ImmutableMap.of("error", error_message), response.getEntity());
}

  protected Response handleConstraintViolationException(ConstraintViolationException cve) {
    ViolationReport report = new ViolationReport();
    for (ConstraintViolation cv : cve.getConstraintViolations()) {
      report.addConstraintViolation(new RestConstraintViolation(
          cv.getPropertyPath().toString(),
          cv.getMessage(),
          cv.getInvalidValue() == null ? "null" : cv.getInvalidValue().toString()));
    }
    // TODO for now just do xml output
    return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(report).type(ContentType.TEXT_XML_UTF_8).build();
  }
}

public String start() {
  final Response response = addProperties(client.target(requestTokenUri).request())
      .post(null);
  if (response.getStatus() != 200) {
    throw new RuntimeException(LocalizationMessages.ERROR_REQUEST_REQUEST_TOKEN(response.getStatus()));
  }
  final MultivaluedMap<String, String> formParams = response.readEntity(Form.class).asMap();
  parameters.token(formParams.getFirst(OAuth1Parameters.TOKEN));
  secrets.tokenSecret(formParams.getFirst(OAuth1Parameters.TOKEN_SECRET));
  return UriBuilder.fromUri(authorizationUri).queryParam(OAuth1Parameters.TOKEN, parameters.getToken())
      .build().toString();
}