How to use

NamespaceNotFoundException

in

co.cask.cdap.common

@Override
public NamespaceMeta get(final NamespaceId namespaceId) throws Exception {
 Iterable<NamespaceMeta> filtered = Iterables.filter(namespaces, new Predicate<NamespaceMeta>() {
  @Override
  public boolean apply(NamespaceMeta input) {
   return input.getName().equals(namespaceId.getNamespace());
  }
 });
 if (Iterables.size(filtered) == 0) {
  throw new NamespaceNotFoundException(namespaceId);
 }
 return filtered.iterator().next();
}

 private static void verifyNotFound(NamespaceId namespaceId) throws Exception {
  try {
   namespaceAdmin.get(namespaceId);
   Assert.fail(String.format("Namespace '%s' should not be found since it was just deleted",
                namespaceId.getNamespace()));
  } catch (NamespaceNotFoundException e) {
   Assert.assertEquals(namespaceId, e.getId());
  }
 }
}

 Assert.fail("Namespace 'random' should not exist.");
} catch (NamespaceNotFoundException e) {
 Assert.assertEquals(new NamespaceId("random"), e.getId());

private NamespaceMeta fetchNamespaceMeta(NamespaceId namespaceId) throws Exception {
 NamespaceMeta ns = nsStore.get(namespaceId);
 if (ns == null) {
  throw new NamespaceNotFoundException(namespaceId);
 }
 return ns;
}

private NamespaceMeta fetchNamespaceMeta(NamespaceId namespaceId) throws Exception {
 NamespaceMeta ns = nsStore.get(namespaceId);
 if (ns == null) {
  throw new NamespaceNotFoundException(namespaceId);
 }
 return ns;
}

/**
 * Validates if secret manager is loaded and the provided namespace exists.
 */
private void validate(String namespace) throws Exception {
 if (secretManager == null) {
  throw new RuntimeException("Secret manager is either not initialized or not loaded. ");
 }
 NamespaceId namespaceId = new NamespaceId(namespace);
 if (!namespaceQueryAdmin.exists(namespaceId)) {
  throw new NamespaceNotFoundException(namespaceId);
 }
}

@Override
public synchronized NamespaceMeta get(NamespaceId namespaceId) throws Exception {
 NamespaceMeta meta = namespaces.get(namespaceId);
 if (meta == null) {
  throw new NamespaceNotFoundException(namespaceId);
 }
 return meta;
}

@Override
public synchronized void delete(NamespaceId namespaceId) throws Exception {
 if (namespaces.remove(namespaceId) == null) {
  throw new NamespaceNotFoundException(namespaceId);
 }
}

/**
 * Throws an exception if the specified namespace is not the system namespace and does not exist
 */
private void ensureNamespaceExists(NamespaceId namespaceId) throws Exception {
 if (!NamespaceId.SYSTEM.equals(namespaceId)) {
  if (!namespaceQueryAdmin.exists(namespaceId)) {
   throw new NamespaceNotFoundException(namespaceId);
  }
 }
}

private void checkNamespaceExists(String namespace) throws Exception {
 NamespaceId namespaceId = new NamespaceId(namespace);
 if (!namespaceQueryAdmin.exists(namespaceId)) {
  throw new NamespaceNotFoundException(namespaceId);
 }
}

 @Override
 public void ensureExists(NamespaceId namespaceId) throws NotFoundException {
  if (!NamespaceId.SYSTEM.equals(namespaceId)) {
   boolean exists = false;
   try {
    exists = namespaceQueryAdmin.exists(namespaceId);
   } catch (Exception e) {
    throw Throwables.propagate(e);
   }
   if (!exists) {
    throw new NamespaceNotFoundException(namespaceId);
   }
  }
 }
}

 /**
  * Throws an exception if the specified namespace is not the system namespace and does not exist
  */
 private void ensureNamespaceExists(NamespaceId namespaceId) throws Exception {
  if (!NamespaceId.SYSTEM.equals(namespaceId)) {
   if (!namespaceQueryAdmin.exists(namespaceId)) {
    throw new NamespaceNotFoundException(namespaceId);
   }
  }
 }
}

private void checkNamespaceExists(String namespace) throws Exception {
 NamespaceId namespaceId = new NamespaceId(namespace);
 if (!namespaceQueryAdmin.exists(namespaceId)) {
  throw new NamespaceNotFoundException(namespaceId);
 }
}

 @Override
 public void ensureExists(NamespaceId namespaceId) throws NotFoundException {
  if (!NamespaceId.SYSTEM.equals(namespaceId)) {
   boolean exists = false;
   try {
    exists = namespaceQueryAdmin.exists(namespaceId);
   } catch (Exception e) {
    throw Throwables.propagate(e);
   }
   if (!exists) {
    throw new NamespaceNotFoundException(namespaceId);
   }
  }
 }
}

/**
 * Throws an exception if the specified namespace is not the system namespace and does not exist
 */
private void ensureNamespaceExists(NamespaceId namespaceId) throws Exception {
 if (!NamespaceId.SYSTEM.equals(namespaceId)) {
  if (!namespaceQueryAdmin.exists(namespaceId)) {
   throw new NamespaceNotFoundException(namespaceId);
  }
 }
}

 /**
  * Throws an exception if the specified namespace is not the system namespace and does not exist
  */
 private void ensureNamespaceExists(NamespaceId namespaceId) throws Exception {
  if (!NamespaceId.SYSTEM.equals(namespaceId)) {
   if (!namespaceQueryAdmin.exists(namespaceId)) {
    throw new NamespaceNotFoundException(namespaceId);
   }
  }
 }
}

 @Override
 public synchronized void updateProperties(NamespaceId namespaceId, NamespaceMeta namespaceMeta) throws Exception {
  if (namespaces.replace(namespaceId, namespaceMeta) == null) {
   throw new NamespaceNotFoundException(namespaceId);
  }
 }
}

@Override
public synchronized void deleteDatasets(@Name("namespaceId") NamespaceId namespaceId) throws Exception {
 // TODO: CDAP-870, CDAP-1427: Delete should be in a single transaction.
 if (!exists(namespaceId)) {
  throw new NamespaceNotFoundException(namespaceId);
 }
 if (checkProgramsRunning(namespaceId)) {
  throw new NamespaceCannotBeDeletedException(namespaceId,
                        String.format("Some programs are currently running in namespace " +
                                "'%s', please stop them before deleting datasets " +
                                "in the namespace.",
                               namespaceId));
 }
 try {
  dsFramework.deleteAllInstances(namespaceId);
 } catch (DatasetManagementException | IOException e) {
  LOG.warn("Error while deleting datasets in namespace {}", namespaceId, e);
  throw new NamespaceCannotBeDeletedException(namespaceId, e);
 }
 LOG.debug("Deleted datasets in namespace '{}'.", namespaceId);
}

@Override
public synchronized void deleteDatasets(@Name("namespaceId") NamespaceId namespaceId) throws Exception {
 // TODO: CDAP-870, CDAP-1427: Delete should be in a single transaction.
 if (!exists(namespaceId)) {
  throw new NamespaceNotFoundException(namespaceId);
 }
 if (checkProgramsRunning(namespaceId)) {
  throw new NamespaceCannotBeDeletedException(namespaceId,
                        String.format("Some programs are currently running in namespace " +
                                "'%s', please stop them before deleting datasets " +
                                "in the namespace.",
                               namespaceId));
 }
 try {
  dsFramework.deleteAllInstances(namespaceId);
 } catch (DatasetManagementException | IOException e) {
  LOG.warn("Error while deleting datasets in namespace {}", namespaceId, e);
  throw new NamespaceCannotBeDeletedException(namespaceId, e);
 }
 LOG.debug("Deleted datasets in namespace '{}'.", namespaceId);
}

@Override
public NamespaceMeta get(NamespaceId namespaceId) throws Exception {
 HttpResponse response =
  execute(HttpRequest.get(resolve(String.format("namespaces/%s", namespaceId.getNamespace()))).build());
 if (response.getResponseCode() == HttpURLConnection.HTTP_NOT_FOUND) {
  throw new NamespaceNotFoundException(namespaceId);
 } else if (response.getResponseCode() == HttpURLConnection.HTTP_OK) {
  return ObjectResponse.fromJsonBody(response, NamespaceMeta.class).getResponseObject();
 }
 throw new IOException(String.format("Cannot get namespace %s. Reason: %s",
                   namespaceId, response.getResponseBodyAsString()));
}