@Override public byte[] apply(NamespaceKey input) { return new NamespaceInternalKey(input, keyNormalization).getKey(); } }).toList();
public static NamespaceInternalKey parseKey(byte[] keyBytes) { String path = extractKey(keyBytes, false); return new NamespaceInternalKey(new NamespaceKey(PathUtils.parseFullPath(path))); }
private Iterable<NameSpaceContainer> iterateEntity(final NamespaceKey rootKey) throws NamespaceException { final NamespaceInternalKey rootInternalKey = new NamespaceInternalKey(rootKey, keyNormalization); final Iterable<Map.Entry<byte[], NameSpaceContainer>> entries = namespace.find( new FindByRange<>(rootInternalKey.getRangeStartKey(), false, rootInternalKey.getRangeEndKey(), false)); return FluentIterable.from(entries).transform(input -> input.getValue()); }
@Test public void testNamespaceParseKey() throws Exception { NamespaceInternalKey key = newKey("a.b.c"); NamespaceInternalKey parsedKey = NamespaceInternalKey.parseKey(key.getKey()); assertEquals(key.getPath(), parsedKey.getPath()); assertTrue(Arrays.equals(key.getKey(), parsedKey.getKey())); key = newKey("a.b.c"); parsedKey = NamespaceInternalKey.parseKey(key.getKey()); assertEquals(key.getPath(), parsedKey.getPath()); key = newKey("a"); parsedKey = NamespaceInternalKey.parseKey(key.getKey()); assertEquals(key.getPath(), parsedKey.getPath()); key = newKey("a.b"); parsedKey = NamespaceInternalKey.parseKey(key.getKey()); assertEquals(key.getPath(), parsedKey.getPath()); key = newKey("a.a.a.a"); parsedKey = NamespaceInternalKey.parseKey(key.getKey()); assertEquals(key.getPath(), parsedKey.getPath()); }
try { final Iterable<Map.Entry<byte[], NameSpaceContainer>> containers = namespace.find(new FindByRange<>( NamespaceInternalKey.getRootLookupStart(), false, NamespaceInternalKey.getRootLookupEnd(), false)); switch (type) { case HOME: homeKeys.add(NamespaceInternalKey.parseKey(entry.getKey())); break; case SOURCE: sourcesKeys.add(NamespaceInternalKey.parseKey(entry.getKey())); break; case SPACE: spacesKeys.add(NamespaceInternalKey.parseKey(entry.getKey())); break; default: builder.append("\n"); for (NamespaceInternalKey key : sourcesKeys) { builder.append(getSource(key.getPath()).toString()); builder.append("\n"); for (NameSpaceContainer container : traverseEntity(key.getPath())) { builder.append(container.toString()); builder.append("\n"); builder.append("\n"); for (NamespaceInternalKey key : spacesKeys) { builder.append(getSpace(key.getPath()).toString()); builder.append("\n"); for (NameSpaceContainer container : traverseEntity(key.getPath())) {
isPhysicalDataset(newOrUpdatedEntity.getContainer().getDataset().getType()) && existingContainer.getType() == FOLDER) { namespace.delete((new NamespaceInternalKey(new NamespaceKey(existingContainer.getFullPathList()), keyNormalization)).getKey(), existingContainer.getFolder().getTag()); return false; throw UserException.validationError() .message("There already exists an entity of type [%s] at given path [%s]", existingContainer.getType(), newOrUpdatedEntity.getPathKey().getPath()) .build(logger);
@Test public void testNamespaceRangeKey() throws Exception { assertEquals("3.a.2.b.1.c.0.", NamespaceInternalKey.extractRangeKey(newKey("a.b.c").getRangeStartKey())); assertEquals("3.a1.2.b.1.c.0.", NamespaceInternalKey.extractRangeKey(newKey("a1.b.c").getRangeStartKey())); assertEquals("1.a.0.", NamespaceInternalKey.extractRangeKey(newKey("a").getRangeStartKey())); assertEquals("2.a.1.b.0.", NamespaceInternalKey.extractRangeKey(newKey("a.b").getRangeStartKey())); assertEquals("4.a.3.a.2.a.1.a.0.", NamespaceInternalKey.extractRangeKey(newKey("a.a.a.a").getRangeStartKey())); assertEquals("4.a.3.a.2.a.1.a.0.", NamespaceInternalKey.extractRangeKey(newKey("a.a.a.a").getRangeEndKey())); }
@Test public void testNamespaceIntToPrefix() throws Exception { for (int n = 0; n < 1 << 16; ++n) { assertEquals(n, NamespaceInternalKey.prefixBytesToInt(NamespaceInternalKey.toPrefixBytes(n))); } }
@Test public void testNamespaceKey() throws Exception { assertEquals("2.a.1.b.0.c", NamespaceInternalKey.extractKey(newKey("a.b.c").getKey(), true)); assertEquals("2.a1.1.b.0.c", NamespaceInternalKey.extractKey(newKey("a1.b.c").getKey(), true)); assertEquals("0.a", NamespaceInternalKey.extractKey(newKey("a").getKey(), true)); assertEquals("1.a.0.b", NamespaceInternalKey.extractKey(newKey("a.b").getKey(), true)); assertEquals("3.a.2.a.1.a.0.a", NamespaceInternalKey.extractKey(newKey("a.a.a.a").getKey(), true)); }
/** * Helper method which creates a new entity or update the existing entity with given entity * * @param entity * @throws NamespaceException */ private void createOrUpdateEntity(final NamespaceEntity entity, NamespaceAttribute... attributes) throws NamespaceException { final NamespaceKey entityPath = entity.getPathKey().getPath(); final List<NameSpaceContainer> entitiesOnPath = getEntitiesOnPath(entityPath); doCreateOrUpdateEntity(entity, entitiesOnPath, attributes); }
protected void doCreateOrUpdateEntity(final NamespaceEntity entity, List<NameSpaceContainer> entitiesOnPath, NamespaceAttribute... attributes) throws NamespaceException { final NameSpaceContainer prevContainer = lastElement(entitiesOnPath); ensureIdExistsTypeMatches(entity, prevContainer); namespace.put(entity.getPathKey().getKey(), entity.getContainer()); }
private static NamespaceInternalKey newKey(String path) { return new NamespaceInternalKey(new NamespaceKey(PathUtils.parseFullPath(path))); } }
private static int extractLevelFromDelimiterPrefix(byte[] keyBytes, int delimiterStart) { return prefixBytesToInt( Arrays.copyOfRange( keyBytes, delimiterStart + DELIMITER_BYTES.length, delimiterStart + DELIMITER_BYTES.length + PREFIX_BYTES_SIZE ) ); }
private static final byte[][] generatePrefixes() { // will generate all possible numbers on 2 bytes final byte[][] prefixes = new byte[1 << (PREFIX_BYTES_SIZE * 8)][]; for (int i = 0; i < prefixes.length; ++i) { // `` + {i on 2 bytes} + `` prefixes[i] = new byte[DELIMITER_PREFIX_DELIMITER_SIZE]; System.arraycopy(DELIMITER_BYTES, 0, prefixes[i], 0, DELIMITER_BYTES.length); System.arraycopy(toPrefixBytes(i), 0, prefixes[i], DELIMITER_BYTES.length, PREFIX_BYTES_SIZE); System.arraycopy(DELIMITER_BYTES, 0, prefixes[i], DELIMITER_BYTES.length + PREFIX_BYTES_SIZE, DELIMITER_BYTES.length); } return prefixes; }
public final byte[] getKey() { buildKey(); if (cachedKey == null) { cachedKey = Arrays.copyOfRange(keyBytes, 0, keyLength); } return cachedKey; }
/** * Helper method which travels the tree rooted at the given key and deletes all children in a DFS traversal * (except the root). In order to delete an entity, user should have edit permissions on its parent, * no need of any permission requirements on the entity that is being deleted (Linux FileSystem permission model) * * @param key * @param container * @throws NamespaceException */ private void traverseAndDeleteChildren(final NamespaceInternalKey key, final NameSpaceContainer container) throws NamespaceException { if (!NamespaceUtils.isListable(container.getType())) { return; } for (NameSpaceContainer child : listEntity(key.getPath())) { doTraverseAndDeleteChildren(child); } }
case FOLDER: namespace.delete(searchKey.getKey(), existingContainer.getFolder().getTag()); break;
/** * Helper method that converts the given object into a {@link NamespaceEntity} */ static NamespaceEntity toEntity(Type type, NamespaceKey path, Object config, boolean keyNormalization) { final NameSpaceContainer container = new NameSpaceContainer(); final NamespaceInternalKey namespaceInternalKey = new NamespaceInternalKey(path, keyNormalization); container.setType(type); switch (type) { case DATASET: container.setDataset((DatasetConfig) config); break; case FOLDER: container.setFolder((FolderConfig) config); break; case HOME: container.setHome((HomeConfig) config); break; case SOURCE: container.setSource((SourceConfig) config); break; case SPACE: container.setSpace((SpaceConfig) config); break; default: throw new UnsupportedOperationException("Unknown type: " + type); } container.setFullPathList(path.getPathComponents()); return new NamespaceEntity(namespaceInternalKey, container); } }
public static byte[] getKey(NamespaceKey key) { return new NamespaceInternalKey(key).getKey(); } }
@Override public boolean exists(final NamespaceKey key) { final NameSpaceContainer container = namespace.get(new NamespaceInternalKey(key).getKey()); return container != null; }