public Response deleteQueue(String queueName, Boolean ifUnused, Boolean ifEmpty) { if (Objects.isNull(ifUnused)) { ifUnused = true; } if (Objects.isNull(ifEmpty)) { ifEmpty = true; } try { if (broker.deleteQueue(queueName, ifUnused, ifEmpty)) { return Response.ok().build(); } else { throw new NotFoundException("Queue " + queueName + " doesn't exist."); } } catch (BrokerException e) { throw new BadRequestException(e.getMessage(), e); } }
/** * Add a segment of a binary. * * <p>Note: the response will be a json structure, such as:</p> * <pre>{ * "digest": "a-hash" * }</pre> * * @param id the upload session identifier * @param partNumber the part number * @param part the input stream * @return a response */ @PUT @Timed @Path("{partNumber}") @Produces("application/json") public String uploadPart(@PathParam("id") final String id, @PathParam("partNumber") final Integer partNumber, final InputStream part) { final JsonObjectBuilder builder = Json.createObjectBuilder(); if (!binaryService.uploadSessionExists(id)) { throw new NotFoundException(); } final String digest = binaryService.uploadPart(id, partNumber, part); return builder.add("digest", digest).build().toString(); }
@Override public Response toResponse(NotFoundException ex) { if (ex.getCause() instanceof IllegalArgumentException) { // If a URL parameter cannot be decoded (e.g. an invalid UUID) an IllegalArgumentException will be wrapped inside // a NotFoundException. But a 412 should be returned in this case. return ResultStash.builder() .setStatus(Response.Status.PRECONDITION_FAILED) .addActionError("Invalid URL parameter detected.", "invalid.url.parameter") .buildResponse(); } return ResultStash.builder() .setStatus(Response.Status.NOT_FOUND) .addActionError("Requested URL does not exist.", "url.not.exist") .buildResponse(); }
@GET @Path("{LraId}") @Produces(MediaType.TEXT_PLAIN) @ApiOperation(value = "Obtain the status of an LRA as a string", response = String.class) @ApiResponses( { @ApiResponse( code = 404, message = "The coordinator has no knowledge of this LRA" ), @ApiResponse( code = 204, message = "The LRA exists and has not yet been asked to close or cancel " + " - compare this response with a 200 response.s"), @ApiResponse( code = 200, message = "The LRA exists. The status is reported in the content body.") } ) public Response getLRAStatus( @ApiParam( value = "The unique identifier of the LRA", required = true ) @PathParam("LraId")String lraId) throws NotFoundException { CompensatorStatus status = lraService.getTransaction(toURL(lraId)).getLRAStatus(); if (status == null) return Response.noContent().build(); // 204 means the LRA is still active return Response.ok(status.name()).build(); }
@PUT @Path("{LraId}/renew") @ApiOperation(value = "Update the TimeLimit for an existing LRA", notes = "LRAs can be automatically cancelled if they aren't closed or cancelled before the TimeLimit\n" + "specified at creation time is reached.\n" + "The time limit can be updated.\n") @ApiResponses({ @ApiResponse( code = 200, message = "If the LRA timelimit has been updated" ), @ApiResponse( code = 404, message = "The coordinator has no knowledge of this LRA" ), @ApiResponse( code = 412, message = "The LRA is not longer active (ie in the complete or compensate messages have been sent" ) } ) public Response renewTimeLimit( @ApiParam( value = "The new time limit for the LRA", required = true ) @QueryParam(TIMELIMIT_PARAM_NAME) @DefaultValue("0") Long timelimit, @PathParam("LraId")String lraId) throws NotFoundException { return Response.status(lraService.renewTimeLimit(toURL(lraId), timelimit)).build(); }
@PUT @Path("{LraId}/close") @Produces(MediaType.APPLICATION_JSON) @ApiOperation(value = "Attempt to close an LRA", notes = "Trigger the successful completion of the LRA. All" +" compensators will be dropped by the coordinator." +" The complete message will be sent to the compensators." +" Upon termination, the URL is implicitly deleted." +" The invoker cannot know for sure whether the lra completed or compensated without enlisting a participant.", response = Boolean.class) @ApiResponses( { @ApiResponse( code = 404, message = "The coordinator has no knowledge of this LRA" ), @ApiResponse( code = 200, message = "The complete message was sent to all coordinators" ) } ) public Response closeLRA( @ApiParam( value = "The unique identifier of the LRA", required = true ) @PathParam("LraId")String txId) throws NotFoundException { return endLRA(toURL(txId), false, false); }
@PUT @Path("{LraId}/cancel") @Produces(MediaType.APPLICATION_JSON) @ApiOperation(value = "Attempt to cancel an LRA", notes = " Trigger the compensation of the LRA. All" + " compensators will be triggered by the coordinator (ie the compensate message will be sent to each compensators)." + " Upon termination, the URL is implicitly deleted." + " The invoker cannot know for sure whether the lra completed or compensated without enlisting a participant.", response = Boolean.class) @ApiResponses( { @ApiResponse( code = 404, message = "The coordinator has no knowledge of this LRA" ), @ApiResponse( code = 200, message = "The compensate message was sent to all coordinators" ) } ) public Response cancelLRA( @ApiParam( value = "The unique identifier of the LRA", required = true ) @PathParam("LraId")String lraId) throws NotFoundException { return endLRA(toURL(lraId), true, false); }
private <T> Try<NestedCollectionRoutes<T>> _getNestedCollectionRoutesTry( String name, String nestedName) { Try<Optional<NestedCollectionRoutes<T>>> optionalTry = Try.success( _nestedCollectionRouterManager.getNestedCollectionRoutesOptional( name, nestedName)); return optionalTry.map( Optional::get ).recoverWith( __ -> _getReusableNestedCollectionRoutesTry(nestedName) ).mapFailMatching( NoSuchElementException.class, () -> new NotFoundException("No resource found for path " + name) ); }
private Response joinLRA(URL lraId, long timeLimit, String compensatorUrl, String linkHeader, String userData) throws NotFoundException { final String recoveryUrlBase = String.format("http://%s/%s/", context.getRequestUri().getAuthority(), NarayanaLRAClient.RECOVERY_COORDINATOR_PATH_NAME); StringBuilder recoveryUrl = new StringBuilder(); int status = lraService.joinLRA(recoveryUrl, lraId, timeLimit, compensatorUrl, linkHeader, recoveryUrlBase, userData); try { return Response.status(status) .entity(recoveryUrl) .location(new URI(recoveryUrl.toString())) .header(LRA_HTTP_RECOVERY_HEADER, recoveryUrl) .build(); } catch (URISyntaxException e) { LRALogger.i18NLogger.error_invalidRecoveryUrlToJoinLRA(recoveryUrl.toString(), lraId); throw new GenericLRAException(lraId, Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), "Invalid recovery URL", e); } }
public Response handle(final MinijaxRequestContext context) { final MinijaxResourceMethod rm = findRoute(context.getMethod(), (MinijaxUriInfo) context.getUriInfo()); if (rm == null) { return toResponse(context, new NotFoundException()); } context.setResourceMethod(rm); try { if (securityContextClass != null) { context.setSecurityContext(get(securityContextClass)); } runRequestFilters(context); checkSecurity(context); final Response response = toResponse(rm, rm.invoke(context)); runResponseFilters(context, response); return response; } catch (final Exception ex) { LOG.debug(ex.getMessage(), ex); return toResponse(context, ex); } }
/** * Tests that a fetch of a non-existent port chain object throws an exception. */ @Test public void testBadGet() { expect(portChainService.getPortChain(anyObject())) .andReturn(null).anyTimes(); replay(portChainService); WebTarget wt = target(); try { wt.path("port_chains/78dcd363-fc23-aeb6-f44b-56dc5aafb3ae") .request().get(String.class); fail("Fetch of non-existent port chain did not throw an exception"); } catch (NotFoundException ex) { assertThat(ex.getMessage(), containsString("HTTP 404 Not Found")); } }
@Override public Response toResponse(Exception exception) { if (exception instanceof NotFoundException) { return Response.status(Response.Status.NOT_FOUND).build(); } UUID eventId = UUID.randomUUID(); LOG.error(MessageFormat.format("{0} - Exception while processing request.", eventId), exception); StringBuilder sb = new StringBuilder(); sb.append(exception.getClass().getName()); if (configuration.getReturnStackTraceInResponse()) { sb.append(" : "); sb.append(exception.getMessage()); sb.append("\n"); for (StackTraceElement element : exception.getStackTrace()) { sb.append("! "); sb.append(element.toString()); sb.append("\n"); } } return Response.serverError().entity(sb.toString()).build(); }
/** * Tests that a fetch of a non-existent intent object throws an exception. */ @Test public void testBadGet() { expect(mockIntentService.getIntent(Key.of(0, APP_ID))) .andReturn(null) .anyTimes(); replay(mockIntentService); WebTarget wt = target(); try { wt.path("intents/0").request().get(String.class); fail("Fetch of non-existent intent did not throw an exception"); } catch (NotFoundException ex) { assertThat(ex.getMessage(), containsString("HTTP 404 Not Found")); } }
/** * Tests that a fetch of a non-existent device object throws an exception. */ @Test public void testBadGet() { expect(mockFlowService.getFlowEntries(anyObject())) .andReturn(null).anyTimes(); replay(mockFlowService); replay(mockDeviceService); WebTarget wt = target(); try { wt.path("flows/0").request().get(String.class); fail("Fetch of non-existent device did not throw an exception"); } catch (NotFoundException ex) { assertThat(ex.getMessage(), containsString("HTTP 404 Not Found")); } }
/** * Tests that a fetch of a non-existent port pair group object throws an exception. */ @Test public void testBadGet() { expect(portPairGroupService.getPortPairGroup(anyObject())) .andReturn(null).anyTimes(); replay(portPairGroupService); WebTarget wt = target(); try { wt.path("port_pair_groups/78dcd363-fc23-aeb6-f44b-56dc5aafb3ae") .request().get(String.class); fail("Fetch of non-existent port pair group did not throw an exception"); } catch (NotFoundException ex) { assertThat(ex.getMessage(), containsString("HTTP 404 Not Found")); } }
/** * Tests that a DELETE of a non-existent device key throws an exception. */ @Test public void testDeleteNonExistentDeviceKey() { expect(mockDeviceKeyService.getDeviceKey(anyObject())) .andReturn(null) .anyTimes(); expectLastCall(); replay(mockDeviceKeyService); replay(mockDeviceKeyAdminService); WebTarget wt = target(); try { wt.path("keys/" + "NON_EXISTENT_DEVICE_KEY").request() .delete(String.class); fail("Delete of a non-existent device key did not throw an exception"); } catch (NotFoundException ex) { assertThat(ex.getMessage(), containsString("HTTP 404 Not Found")); } verify(mockDeviceKeyService); verify(mockDeviceKeyAdminService); }
private Optional<User> _getUserOptional(JournalArticle journalArticle) { try { return Optional.ofNullable( _userService.getUserById(journalArticle.getUserId())); } catch (NoSuchUserException | PrincipalException e) { throw new NotFoundException( "Unable to get user " + journalArticle.getUserId(), e); } catch (PortalException pe) { throw new ServerErrorException(500, pe); } }
/** * Returns the {@link News} with the given id. * @param id the content id of the {@link News}. * @param userId the {@link User} which wants to see the {@link News}. * @param con the {@link Connection} to get the {@link News}. * @return {@link News} * @throws NotFoundException if {@link News} doesn't exists. */ @GET public Response getNews(@PathParam("id") final long id, @QueryParam("userId") final long userId, @Context final Connection con) { final News news = new NewsDao(con).getNews(id); if(news == null) { throw new NotFoundException("News with id " + id + " not found."); } return ok(new NewsModel(news, userId, con)); }
/** * Get a list of the uploads. * * <p>Note: the response structure will be like this:</p> * <pre>{ * "1": "somehash", * "2": "otherhash", * "3": "anotherhash" * }</pre> * * @param id the upload id * @return a response */ @GET @Timed @Produces("application/json") public String listUploads(@PathParam("id") final String id) { final JsonObjectBuilder builder = Json.createObjectBuilder(); if (!binaryService.uploadSessionExists(id)) { throw new NotFoundException(); } binaryService.listParts(id).forEach(x -> builder.add(x.getKey().toString(), x.getValue())); return builder.build().toString(); }
/** * Abort an upload process. * * @param id the upload identifier */ @DELETE @Timed public void abortUpload(@PathParam("id") final String id) { if (!binaryService.uploadSessionExists(id)) { throw new NotFoundException(); } binaryService.abortUpload(id); }
@Override public final Response toResponse(TException exception) { if (exception instanceof NotFoundException) { return Response.status(Response.Status.NOT_FOUND).build(); } else if (noSessionIdInQueryStringOrPathParam() && inARequestWhereWeExpectContext()) { LOG.error(MessageFormat.format("No Session Id found for request to: {0}", httpServletRequest.getRequestURI()), exception); return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build(); } return handleException(exception); }
@Override public void onEvent(RequestEvent event) { ContainerRequest containerRequest = event.getContainerRequest(); Set<Timed> timedAnnotations; switch (event.getType()) { case ON_EXCEPTION: if(!(event.getException() instanceof NotFoundException)) { break; } case REQUEST_MATCHED: timedAnnotations = annotations(event); timedAnnotationsOnRequest.put(containerRequest, timedAnnotations); shortTaskSample.put(containerRequest, Timer.start(registry)); List<LongTaskTimer.Sample> longTaskSamples = longTaskTimers(timedAnnotations, event).stream().map(LongTaskTimer::start).collect(Collectors.toList()); if (!longTaskSamples.isEmpty()) { this.longTaskSamples.put(containerRequest, longTaskSamples); } break; case FINISHED: timedAnnotations = timedAnnotationsOnRequest.remove(containerRequest); Timer.Sample shortSample = shortTaskSample.remove(containerRequest); if (shortSample != null) { for (Timer timer : shortTimers(timedAnnotations, event)) { shortSample.stop(timer); } } Collection<LongTaskTimer.Sample> longSamples = this.longTaskSamples.remove(containerRequest); if (longSamples != null) { for (LongTaskTimer.Sample longSample : longSamples) { longSample.stop(); } } break; } }
@Override public Response toResponse(NotFoundException e) { return Response.status(Response.Status.NOT_FOUND) .entity(new org.crunchytorch.coddy.application.data.Response(org.crunchytorch.coddy.application.data.Response.PAGE_NOT_FOUND)) .type(MediaType.APPLICATION_JSON) .build(); }
@Override public Response toResponse(NotFoundException exception) { LOGGER.debug("Resource not found.", exception); Map<String, Object> errorResponse = new HashMap<>(); errorResponse.put("message", exception.getMessage()); return Response.status(Response.Status.NOT_FOUND) .entity(errorResponse) .type(MediaType.APPLICATION_JSON_TYPE) .build(); }
public Response getQueue(String queueName) { QueueHandler queueHandler = broker.getQueue(queueName); if (Objects.isNull(queueHandler)) { throw new NotFoundException("Queue " + queueName + " not found"); } QueueMetadata queueMetadata = toQueueMetadata(queueHandler); return Response.ok().entity(queueMetadata).build(); }
public Response getAllConsumers(String queueName) { QueueHandler queueHandler = broker.getQueue(queueName); if (Objects.isNull(queueHandler)) { throw new NotFoundException("Unknown queue Name " + queueName); } Collection<Consumer> consumers = queueHandler.getConsumers(); List<ConsumerMetadata> consumerMetadataList = new ArrayList<>(consumers.size()); for (Consumer consumer : consumers) { consumerMetadataList.add(toConsumerMetadata(consumer)); } return Response.ok().entity(consumerMetadataList).build(); }
private BlogsEntry _getBlogsEntry(Long blogsEntryId) { try { return _blogsService.getEntry(blogsEntryId); } catch (NoSuchEntryException | PrincipalException e) { throw new NotFoundException( "Unable to get blogs entry " + blogsEntryId, e); } catch (PortalException pe) { throw new ServerErrorException(500, pe); } }
public Person getPerson(int id) { if (id < persons.size()) { return persons.get(id); } throw new NotFoundException("Person with id \"" + id + "\" not found."); }
private BlogPosting _updateBlogPosting( Long blogPostingId, BlogPostingForm blogPostingForm) { Optional<BlogPosting> optional = BlogPosting.updateBlogPosting( blogPostingId, blogPostingForm.getArticleBody(), blogPostingForm.getCreator(), blogPostingForm.getAlternativeHeadline(), blogPostingForm.getHeadline()); return optional.orElseThrow( () -> new NotFoundException( "Unable to get blog posting " + blogPostingId)); }
private User _getUser(Long userId) { try { return _userLocalService.getUserById(userId); } catch (NoSuchUserException | PrincipalException e) { throw new NotFoundException("Unable to get user " + userId, e); } catch (PortalException pe) { throw new ServerErrorException(500, pe); } }
@GET @Path("/status/{LraId}") @Produces(MediaType.APPLICATION_JSON) @ApiOperation(value = "Indicates whether an LRA is active", response = Boolean.class) @ApiResponses( { @ApiResponse( code = 404, message = "The coordinator has no knowledge of this LRA" ), @ApiResponse( code = 200, message = "If the LRA exists" ) } ) public Boolean isActiveLRA( @ApiParam( value = "The unique identifier of the LRA", required = true ) @PathParam("LraId")String lraId) throws NotFoundException { return lraService.getTransaction(toURL(lraId)).isActive(); }
private BlogPosting _getBlogPosting(Long blogPostingId) { Optional<BlogPosting> optional = BlogPosting.getBlogPosting( blogPostingId); return optional.orElseThrow( () -> new NotFoundException( "Unable to get blog posting " + blogPostingId)); }
public boolean isConfigInitialized(KeyValueClient kvClient) { try { List<String> configList = kvClient.getKeys(globalPrefix); if (!configList.isEmpty()) { LOGGER.info("%s exists! The configuration data has been initialized.", globalPrefix); return true; } } catch (NotFoundException e) { LOGGER.info("%s doesn't exist! Start importing configuration data.", globalPrefix); } return false; }
private void send(Collection<Trace> traces) { try { apmApi.reportTraces(traces); } catch (NotFoundException | NotSupportedException cee) { // 404, 415 if (apmApi instanceof ApmApi0_3) { log.info("falling back to json"); fallbackTo0_2(); send(traces); } } catch (BadRequestException bre) { log.error("{}: {}", bre.getMessage(), traces); } }
@GET @Produces(MediaType.APPLICATION_JSON) @Path("/{version}") public Swagger swagger(@PathParam("version") final String version, @Context final UriInfo uriInfo) { if (!collator.isPathExists(version)) { throw new NotFoundException(); } return collator.getSwagger(version, uriInfo); }
@Override public AggregateRatingIdentifier map(Path path) { String id = path.getId(); String[] components = id.split(":"); if (components.length != 2) { throw new BadRequestException( id + " should be a string with the form \"name:classPK\""); } Optional<Class<Object>> optional = _modelClassManager.getModelClassOptional(components[0]); Class<Object> modelClass = optional.orElseThrow( () -> new NotFoundException( "No resource found for path " + components[0])); Try<Long> longTry = Try.fromFallible( () -> Long.parseLong(components[1])); Long classPK = longTry.orElseThrow( () -> new BadRequestException( "Unable to convert " + id + " to a long class PK")); return AggregateRatingIdentifier.create(modelClass.getName(), classPK); }
@Override public Try<Form> getUpdaterFormTry(String name) { Try<ItemRoutes<Object>> itemRoutesTry = _getItemRoutesTry(name); return itemRoutesTry.map( ItemRoutes::getFormOptional ).map( Optional::get ).mapFailMatching( NoSuchElementException.class, NotFoundException::new ); }
@Override public Response toResponse(NotFoundException e) { return Response .status(Response.Status.NOT_FOUND) .type(getMediaType(headers, MediaType.APPLICATION_JSON_TYPE)) .entity(getErrorCodeDto(e)) .build(); }
public ItemResource(ItemsModel itemsModel, String id) { this.id = id; this.itemsModel = itemsModel; try { itemModel = itemsModel.getItem(id); } catch (IndexOutOfBoundsException ex) { throw new NotFoundException(); } }
private DeviceProfile fetchProfile(String deviceProfileName) { try { return deviceProfileClient.deviceProfileForName(deviceProfileName); } catch (NotFoundException nfE) { return null; } }