Java NotFoundException类代码示例

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
private void changeState(String objectId, MachineState newState, Optional<SingularityMachineChangeRequest> changeRequest, Optional<String> user) {
  Optional<String> message = Optional.absent();

  if (changeRequest.isPresent()) {
    message = changeRequest.get().getMessage();
  }

  StateChangeResult result = manager.changeState(objectId, newState, message, user);

  switch (result) {
    case FAILURE_NOT_FOUND:
      throw new NotFoundException(String.format("Couldn't find an active %s with id %s (result: %s)", getObjectTypeString(), objectId, result.name()));
    case FAILURE_ALREADY_AT_STATE:
    case FAILURE_ILLEGAL_TRANSITION:
      throw new ConflictException(String.format("%s - %s %s is in %s state", result.name(), getObjectTypeString(), objectId, newState));
    default:
      break;
  }

}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@DELETE
@Path("/{collection}")
public Response deleteCollection(@PathParam("collection") String collection) throws Exception
{
  StarTreeConfig config = manager.getConfig(collection);
  if (config == null)
  {
    throw new NotFoundException("No collection " + collection);
  }

  manager.close(collection);

  try
  {
    dataUpdateManager.deleteCollection(collection);
  }
  catch (FileNotFoundException e)
  {
    throw new NotFoundException(e.getMessage());
  }

  return Response.noContent().build();
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@GET
@Path("/{collection}/kafkaConfig")
public byte[] getKafkaConfig(@PathParam("collection") String collection) throws Exception
{
  File kafkaConfigFile = new File(new File(rootDir, collection), StarTreeConstants.KAFKA_CONFIG_FILE_NAME);
  if (!kafkaConfigFile.exists())
  {
    throw new NotFoundException();
  }
  if (!kafkaConfigFile.isAbsolute())
  {
    throw new WebApplicationException(Response.Status.BAD_REQUEST);
  }

  return IOUtils.toByteArray(new FileInputStream(kafkaConfigFile));
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@DELETE
@Path("/{collection}/kafkaConfig")
public Response deleteKafkaConfig(@PathParam("collection") String collection) throws Exception
{
  File collectionDir = new File(rootDir, collection);
  if (!collectionDir.isAbsolute())
  {
    throw new WebApplicationException(Response.Status.BAD_REQUEST);
  }

  File kafkaConfigFile = new File(collectionDir, StarTreeConstants.KAFKA_CONFIG_FILE_NAME);
  if (!kafkaConfigFile.exists())
  {
    throw new NotFoundException();
  }

  FileUtils.forceDelete(kafkaConfigFile);

  return Response.noContent().build();
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
public QueryResult checkEmpty() throws NotFoundException {
  if (data.isEmpty()) {
    throw new NotFoundException("No dimension combinations in result");
  }

  boolean allEmpty = true;

  for (Map<String, Number[]> series : data.values()) {
    if (!series.isEmpty()) {
      allEmpty = false;
      break;
    }
  }

  if (allEmpty) {
    throw new NotFoundException("No data for any dimension combination");
  }

  return this;
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
/**
 * build browsing native page with data
 *
 * @param artifactoryRequest  - encapsulate data related to request
 * @param artifactoryResponse - encapsulate data related to response
 * @return - native browsing html page
 */
private String buildPage(ArtifactoryRestRequest artifactoryRequest, RestResponse artifactoryResponse) {
    StringBuilder page = new StringBuilder();
    try {
        HttpServletRequest httpServletRequest = artifactoryRequest.getServletRequest();
        RepoPath repoPath = (RepoPath) httpServletRequest.getAttribute(ATTR_ARTIFACTORY_REPOSITORY_PATH);
        if (repoPath == null || StringUtils.isEmpty(repoPath.getRepoKey())) {
            throw new NotFoundException("Repository Path Not Found");
        }
        // fetch page props
        Properties requestProps = (Properties) httpServletRequest
                .getAttribute(ATTR_ARTIFACTORY_REQUEST_PROPERTIES);
        updatePageData(repoPath, requestProps, artifactoryResponse);
        // fetch page title
        String title = getPageTitle(repoPath);
        // fetch page body
        String body = getBody();
        // fetch page footer
        String addressFooter = getAddressFooter(httpServletRequest);
        // create html page
        createHtmlPage(page, title, body, addressFooter);
    } catch (IOException e) {
        throw new RuntimeException(e.getMessage());
    }
    return page.toString();
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@GET
@Path("/{id}")
@Produces(MediaType.APPLICATION_OCTET_STREAM)
public Response gett(
		@PathParam("id") Long id,
		@QueryParam("revision") @DefaultValue("0") Long revision
		) throws Exception {
	
	Metadata metadata = fileService.load(id,revision);
	if(metadata == null) {
		throw new NotFoundException(); 
	}
	String header = String.format("attachment;filename=\"%s\"",metadata.getName());
	
	return Response.ok(metadata.getFile(),metadata.getMimeType()).header("Content-Disposition",header).build();
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@GET
@Timed
@Path("lookup")
@UnitOfWork
public List<UserTO> lookupToo(@SessionUser User user, @QueryParam("text") String snippet,@QueryParam("p") String projectIdStr) {
	if(snippet == null) throw new NotFoundException();
	if(snippet.length() < 3) throw new NotFoundException();
	Project project = null;
	try {
		Long projectId = null;
		projectId = Long.parseLong(projectIdStr);
		project = this.projectDAO.findById(projectId);
	} catch(NumberFormatException nfe) {}
	User u = this.ud.findByPortionOfEmailUsername(snippet);
	if(u == null) return null;
	// now remove it, if it's already in existence.
	List<UserProject> current= this.upDAO.findByUserIdProjectId(u, project);
	if(current.size() > 0) throw new NotFoundException();
	ArrayList<UserTO> l = new ArrayList<UserTO>();
	l.add(new UserTO(u));
	return l;
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
public ImmutableMap<String, String> getSettings(long id) {
	Builder<String, String> settings = ImmutableMap.<String, String> builder();

	openEntityManager();
	User user;
	try {
		user = find(User.class, id);
		if (user != null) {
			for (UserSetting setting : user.getUserSettings()) {
				settings.put(setting.getKey(), setting.getValue());
			}
		}

	} finally {
		closeEntityManager();
	}

	if (user == null) {
		throw new NotFoundException("No user found with id " + id);
	}
	return settings.build();
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@PUT
@Path(SLASH_USERNAME)
public Viewable putUser(@PathParam(USERNAME) String username, @FormParam(REALNAME) String realname, @FormParam(EMAIL) String emailAddress, @FormParam(ENABLED) String enabled,
		@FormParam(EXTERNAL_REF_ID) String externalRefId, @FormParam(MAX_INSTANCES) String maxInstancesStr, @FormParam(MAX_CORES) String maxCoresStr) {
	LOG.info(String.format("Updating a new user: username %s, real name %s, email %s, enabled %s, external ref id %s, maxInstances %s, maxCores %s", username, realname, emailAddress, enabled,
			externalRefId, maxInstancesStr, maxCoresStr));
	Boolean isEnabled = null;

	if (!StringUtils.isEmpty(enabled))
		isEnabled = validateAndGetEnabledBoolean(enabled);

	Integer maxInstances = validateAndGetMaxInstances(maxInstancesStr);
	Integer maxCores = validateAndGetMaxCores(maxCoresStr);
	try {
		userManagementService.updateUser(username, realname, emailAddress, isEnabled, externalRefId, maxInstances, maxCores);
	} catch (UserNotFoundException ex) {
		throw new NotFoundException("");
	}

	return getViewable(getUser(username));
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@Path(SLASH_USERNAME)
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
@GET
public ReadOnlyUser getUser(@PathParam(USERNAME) String username) {
	checkNotNullOrEmpty(username);

	LOG.debug("Getting user " + username);

	try {
		User user = userManagementService.getUser(username);
		if (user.isDeleted()) {
			throw new NotFoundException(USER_HAS_BEEN_DELETED);
		}
		return new ReadOnlyUser(user);
	} catch (UserNotFoundException e) {
		throw new NotFoundException(USER_DOES_NOT_EXIST);
	}
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@Path(SLASH_ACCESS_KEYS)
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
@GET
public ReadOnlyUser getUserByApiAccessKey(@PathParam(ACCESS_KEY) String accessKey) {
	checkNotNullOrEmpty(accessKey);

	LOG.debug(String.format("Getting user with access key %s", accessKey));

	try {
		User user = userManagementService.getUserByApiAccessKey(accessKey);
		if (user.isDeleted()) {
			throw new NotFoundException(USER_HAS_BEEN_DELETED);
		}
		return new ReadOnlyUser(user);
	} catch (UserNotFoundException e) {
		throw new NotFoundException(USER_DOES_NOT_EXIST);
	}
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@POST
@Path(SLASH_USERNAME + SLASH_INSTANCEVALIDATION)
public Response sendInstanceValidationEmail(@PathParam(USERNAME) String username) {
	LOG.debug(String.format("sendInstanceValidationEmail(%s)", username));

	try {
		User user = userManagementService.getUser(username);
		if (user.isDeleted()) {
			throw new NotFoundException(USER_HAS_BEEN_DELETED);
		}
		this.usersInstanceValidationWatcher.sendEmail(user);
		return Response.ok().build();
	} catch (UserNotFoundException e) {
		throw new NotFoundException(USER_DOES_NOT_EXIST);
	}
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@GET
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
public List<ReadOnlyImage> getAllImages(@PathParam(USERNAME) String username) {
	LOG.debug("Getting all images for user " + username);

	Set<Image> images;
	try {
		images = imageService.describeImages(username, null);
	} catch (UserNotFoundException e) {
		throw new NotFoundException();
	}

	List<ReadOnlyImage> readOnlyImages = new ArrayList<ReadOnlyImage>(images.size());

	for (Image image : images) {
		readOnlyImages.add(new ReadOnlyImage(image));
	}

	return readOnlyImages;
}
 

import com.sun.jersey.api.NotFoundException; //导入依赖的package包/类
@Path(SLASH_IMAGEID)
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
@GET
public ReadOnlyImage getImage(@PathParam(USERNAME) String username, @PathParam(IMAGEID) String imageid) {
	checkNotNullOrEmpty(username);
	// String s = IMAGEID;
	LOG.debug("Getting user " + username);

	Set<Image> images;
	try {
		images = imageService.describeImages(username, Arrays.asList(imageid));
	} catch (UserNotFoundException e) {
		throw new NotFoundException();
	}
	return new ReadOnlyImage(images.iterator().next());
}