@Override public int getAllDatasetsCount(NamespaceKey parent) throws NamespaceException { int count = 0; for (final NameSpaceContainer container : traverseEntity(parent)) { if (container.getType() == DATASET) { ++count; } } return count; }
private List<CatalogItem> getListingForInternalItem(List<String> path) throws NamespaceException { NameSpaceContainer rootEntity = getNamespaceEntity(new NamespaceKey(path.get(0))); if (rootEntity.getType() == NameSpaceContainer.Type.SOURCE) { return getChildrenForPath(new NamespaceKey(path)); } throw new IllegalArgumentException(String.format("Can only get listing for sources, but [%s] is of type [%s]", path, rootEntity.getType())); }
public List<ResourceTreeEntity> listPath(NamespaceKey root, boolean showDatasets) throws NamespaceException, UnsupportedEncodingException { final List<ResourceTreeEntity> resources = Lists.newArrayList(); for (NameSpaceContainer container : namespaceService.get().list(root)) { if (container.getType() == Type.FOLDER) { resources.add(new ResourceTreeEntity(container.getFolder())); } else if (showDatasets && container.getType() == Type.DATASET) { resources.add(new ResourceTreeEntity(container.getDataset())); } } return resources; }
private Optional<CatalogItem> getInternalItemByPath(List<String> path) throws NamespaceException { NameSpaceContainer rootEntity = getNamespaceEntity(new NamespaceKey(path.get(0))); if (rootEntity != null && rootEntity.getType() == NameSpaceContainer.Type.SOURCE) { return Optional.of(getInternalItemFromSource(rootEntity.getSource(), path)); } else { logger.warn("Can not find internal item with path [%s].", path); return Optional.absent(); } }
private Collection<NameSpaceContainer> traverseEntity(final NamespaceKey root) throws NamespaceException { final LinkedList<NameSpaceContainer> toBeTraversed = new LinkedList<>(listEntity(root)); final LinkedList<NameSpaceContainer> visited = new LinkedList<>(); while (!toBeTraversed.isEmpty()) { final NameSpaceContainer container = toBeTraversed.removeFirst(); if (NamespaceUtils.isListable(container.getType())) { toBeTraversed.addAll(listEntity(new NamespaceKey(container.getFullPathList()))); } visited.add(container); } return visited; }
private void validateEntityForTag(String entityId) throws NamespaceException { final NameSpaceContainer entity = validateEntity(entityId); if (entity.getType() != NameSpaceContainer.Type.DATASET) { throw UserException.validationError() .message("Tags can only be set on datasets but found [%s].", entity.getType()) .build(logger); } }
private static DatasetType getType(NamespaceService service, List<String> namespacePath){ try{ List<NameSpaceContainer> containers = service.getEntities(Collections.singletonList(new NamespaceKey(namespacePath))); if(containers != null && !containers.isEmpty()){ NameSpaceContainer container = containers.get(0); if(container.getType() == Type.DATASET){ return container.getDataset().getType(); } } }catch(Exception ex){ } return null; }
@Override public Iterable<NamespaceKey> getAllDatasets(final NamespaceKey root) throws NamespaceException { final NameSpaceContainer rootContainer = namespace.get(new NamespaceInternalKey(root, keyNormalization).getKey()); if (rootContainer == null) { return Collections.emptyList(); } if (!isListable(rootContainer.getType())) { return Collections.emptyList(); } return () -> new LazyIteratorOverDatasets(root); }
@Override public boolean exists(final NamespaceKey key, final Type type) { final NameSpaceContainer container = namespace.get(new NamespaceInternalKey(key, keyNormalization).getKey()); return container != null && container.getType() == type; }
@GET @Path("search") @Produces(MediaType.APPLICATION_JSON) public DatasetSearchUIs searchDatasets(@QueryParam("filter") String filters, @QueryParam("sort") String sortColumn, @QueryParam("order") SortOrder order) throws NamespaceException, DatasetVersionNotFoundException { final DatasetSearchUIs datasets = new DatasetSearchUIs(); for (SearchContainer searchEntity : catalogServiceHelper.searchByQuery(filters)) { if (searchEntity.getNamespaceContainer().getType().equals(NameSpaceContainer.Type.DATASET)) { datasets.add(new DatasetSearchUI(searchEntity.getNamespaceContainer().getDataset(), searchEntity.getCollaborationTag())); } } return datasets; }
@VisibleForTesting public List<CatalogItem> getChildrenForPath(NamespaceKey path) throws NamespaceException { final List<CatalogItem> catalogItems = new ArrayList<>(); // get parent info NameSpaceContainer rootEntity = getNamespaceEntity(new NamespaceKey(path.getPathComponents().get(0))); if (rootEntity.getType() == NameSpaceContainer.Type.SOURCE) { catalogItems.addAll(getChildrenForSourcePath(rootEntity.getSource().getName(), path.getPathComponents())); } else { // for non-source roots, go straight to the namespace catalogItems.addAll(getNamespaceChildrenForPath(path)); } return catalogItems; }
@GET @Path("parents") @Produces(APPLICATION_JSON) public List<ParentDatasetUI> getParents() throws DatasetNotFoundException, NamespaceException { final VirtualDatasetUI virtualDatasetUI = datasetService.get(datasetPath, version); final List<ParentDatasetUI> parentDatasetUIs = Lists.newArrayList(); final List<NamespaceKey> parentDatasetPaths = Lists.newArrayList(); for (ParentDataset parentDataset : virtualDatasetUI.getParentsList()) { parentDatasetPaths.add(new NamespaceKey(parentDataset.getDatasetPathList())); } for (NameSpaceContainer nameSpaceContainer : datasetService.getNamespaceService().getEntities(parentDatasetPaths)) { if (nameSpaceContainer != null && nameSpaceContainer.getType() == Type.DATASET) { parentDatasetUIs.add(new ParentDatasetUI(nameSpaceContainer.getFullPathList(), nameSpaceContainer.getDataset().getType())); } } return parentDatasetUIs; }
/** * Helper method which retrieves the entity with given key. No authorization check done. * * @param key * @return * @throws NamespaceException */ private NameSpaceContainer getEntity(final NamespaceKey key, Type type) throws NamespaceException { final List<NameSpaceContainer> entitiesOnPath = getEntitiesOnPath(key); NameSpaceContainer container = lastElement(entitiesOnPath); if (container == null || container.getType() != type) { throw new NamespaceNotFoundException(key, "not found"); } return doGetEntity(key, type, entitiesOnPath); }
@Override public String getTag(NameSpaceContainer value) { switch (value.getType()) { case DATASET: return value.getDataset().getTag(); case FOLDER: return value.getFolder().getTag(); case HOME: return value.getHome().getTag(); case SOURCE: return value.getSource().getTag(); case SPACE: return value.getSpace().getTag(); default: throw new UnsupportedOperationException("Unknown type: " + value.getType()); } }
protected NameSpaceContainer getEntityByIndex(IndexKey key, String index, Type type) throws NamespaceException { NameSpaceContainer namespaceContainer = getByIndex(key, index); if (namespaceContainer == null || namespaceContainer.getType() != type) { throw new NamespaceNotFoundException(new NamespaceKey(key.toString()), "not found"); } return namespaceContainer; }
@Override public Long getVersion(NameSpaceContainer value) { switch (value.getType()) { case DATASET: return value.getDataset().getVersion(); case FOLDER: return value.getFolder().getVersion(); case HOME: return value.getHome().getVersion(); case SOURCE: return value.getSource().getVersion(); case SPACE: return value.getSpace().getVersion(); default: throw new UnsupportedOperationException("Unknown type: " + value.getType()); } }
protected void updateFolder(Folder folder, NamespaceAttribute... attributes) throws NamespaceException { NamespaceKey namespaceKey = new NamespaceKey(folder.getPath()); FolderConfig folderConfig = namespaceService.getFolder(namespaceKey); Preconditions.checkArgument(CollectionUtils.isEqualCollection(folder.getPath(), folderConfig.getFullPathList()), "Folder path is immutable."); NameSpaceContainer rootContainer = getRootContainer(folder.getPath()); if (rootContainer.getType() == NameSpaceContainer.Type.SOURCE) { throw new UnsupportedOperationException("Can not update a folder inside a source"); } namespaceService.addOrUpdateFolder(namespaceKey, getFolderConfig(folder), attributes); }
@Override public List<NameSpaceContainer> list(NamespaceKey root) throws NamespaceException { final List<NameSpaceContainer> entitiesOnPath = getEntitiesOnPath(root); final NameSpaceContainer rootContainer = lastElement(entitiesOnPath); if (rootContainer == null) { throw new NamespaceNotFoundException(root, "not found"); } if (!isListable(rootContainer.getType())) { throw new NamespaceNotFoundException(root, "no listable entity found"); } return doList(root, entitiesOnPath); }
protected void doTraverseAndDeleteChildren(final NameSpaceContainer child) throws NamespaceException { final NamespaceInternalKey childKey = new NamespaceInternalKey(new NamespaceKey(child.getFullPathList()), keyNormalization); traverseAndDeleteChildren(childKey, child); switch (child.getType()) { case FOLDER: namespace.delete(childKey.getKey(), child.getFolder().getTag()); break; case DATASET: namespace.delete(childKey.getKey(), child.getDataset().getTag()); break; default: // Only leaf level or intermediate namespace container types are expected here. throw new RuntimeException("Unexpected namespace container type: " + child.getType()); } }
@Override public AutoCloseable preCommit(NameSpaceContainer value) { if (value.getType() != NameSpaceContainer.Type.SOURCE) { return AutoCloseables.noop(); } // for sources, we want to maintain a numeric version so we can distinguish chronological order SourceConfig source = value.getSource(); Long configOrdinal= source.getConfigOrdinal(); value.getSource().setConfigOrdinal(configOrdinal == null ? 0 : configOrdinal + 1); return () -> { // rollback the ordinal in case the commit fails value.getSource().setConfigOrdinal(configOrdinal); }; }