public static Pair<String,String> qualify(String tableName) { return qualify(tableName, Namespace.DEFAULT); }
@Override public boolean test(String tableName) { return !Namespace.ACCUMULO.equals(qualify(tableName).getFirst()); }
/** * @param tableName * the original specified table * @param e * indicates that a table wasn't found because the namespace specified in the table name * wasn't found */ public TableNotFoundException(String tableName, NamespaceNotFoundException e) { this(null, tableName, "Namespace " + Tables.qualify(tableName).getFirst() + " does not exist.", e); }
@Override protected void pruneTables(Set<String> tables) { Iterator<String> tableNames = tables.iterator(); while (tableNames.hasNext()) { String table = tableNames.next(); Pair<String,String> qualifiedName = Tables.qualify(table); if (Namespace.ACCUMULO.equals(qualifiedName.getFirst())) { log.trace("Removing table from deletion set: {}", table); tableNames.remove(); } } } }
public static List<Table.ID> getTableIds(ClientContext context, Namespace.ID namespaceId) throws NamespaceNotFoundException { String namespace = getNamespaceName(context, namespaceId); List<Table.ID> tableIds = new LinkedList<>(); for (Entry<String,Table.ID> nameToId : Tables.getNameToIdMap(context).entrySet()) if (namespace.equals(Tables.qualify(nameToId.getKey()).getFirst())) tableIds.add(nameToId.getValue()); return tableIds; }
public static List<String> getTableNames(ClientContext context, Namespace.ID namespaceId) throws NamespaceNotFoundException { String namespace = getNamespaceName(context, namespaceId); List<String> names = new LinkedList<>(); for (String name : Tables.getNameToIdMap(context).keySet()) if (namespace.equals(Tables.qualify(name).getFirst())) names.add(name); return names; }
public CloneZookeeper(CloneInfo cloneInfo, ClientContext context) throws NamespaceNotFoundException { this.cloneInfo = cloneInfo; this.cloneInfo.namespaceId = Namespaces.getNamespaceId(context, Tables.qualify(this.cloneInfo.tableName).getFirst()); }
public static String qualified(String tableName, String defaultNamespace) { Pair<String,String> qualifiedTableName = qualify(tableName, defaultNamespace); if (Namespace.DEFAULT.equals(qualifiedTableName.getFirst())) return qualifiedTableName.getSecond(); else return qualifiedTableName.toString("", ".", ""); }
@SuppressWarnings("unchecked") @Override public int execute(final String fullCommand, final CommandLine cl, final Shell shellState) throws AccumuloException, AccumuloSecurityException, IOException, NamespaceNotFoundException { final String namespace = cl.hasOption(OptUtil.namespaceOpt().getOpt()) ? OptUtil.getNamespaceOpt(cl, shellState) : null; Map<String,String> tables = shellState.getAccumuloClient().tableOperations().tableIdMap(); // filter only specified namespace tables = Maps.filterKeys(tables, tableName -> namespace == null || Tables.qualify(tableName).getFirst().equals(namespace)); final boolean sortByTableId = cl.hasOption(sortByTableIdOption.getOpt()); tables = new TreeMap<String,String>((sortByTableId ? MapUtils.invertMap(tables) : tables)); Iterator<String> it = Iterators.transform(tables.entrySet().iterator(), entry -> { String tableName = String.valueOf(sortByTableId ? entry.getValue() : entry.getKey()); String tableId = String.valueOf(sortByTableId ? entry.getKey() : entry.getValue()); if (namespace != null) tableName = Tables.qualify(tableName).getSecond(); if (cl.hasOption(tableIdOption.getOpt())) return String.format(NAME_AND_ID_FORMAT, tableName, tableId); else return tableName; }); shellState.printLines(it, !cl.hasOption(disablePaginationOpt.getOpt())); return 0; }
/** * Lookup table ID in ZK. If not found, clears cache and tries again. */ public static Table.ID _getTableId(ClientContext context, String tableName) throws NamespaceNotFoundException, TableNotFoundException { Table.ID tableId = getNameToIdMap(context).get(tableName); if (tableId == null) { // maybe the table exist, but the cache was not updated yet... so try to clear the cache and // check again clearCache(context); tableId = getNameToIdMap(context).get(tableName); if (tableId == null) { String namespace = qualify(tableName).getFirst(); if (Namespaces.getNameToIdMap(context).containsKey(namespace)) throw new TableNotFoundException(null, tableName, null); else throw new NamespaceNotFoundException(null, namespace, null); } } return tableId; }
public static void prepareNewTableState(IZooReaderWriter zoo, String instanceId, Table.ID tableId, Namespace.ID namespaceId, String tableName, TableState state, NodeExistsPolicy existsPolicy) throws KeeperException, InterruptedException { // state gets created last log.debug("Creating ZooKeeper entries for new table {} (ID: {}) in namespace (ID: {})", tableName, tableId, namespaceId); Pair<String,String> qualifiedTableName = Tables.qualify(tableName); tableName = qualifiedTableName.getSecond(); String zTablePath = Constants.ZROOT + "/" + instanceId + Constants.ZTABLES + "/" + tableId; zoo.putPersistentData(zTablePath, new byte[0], existsPolicy); zoo.putPersistentData(zTablePath + Constants.ZTABLE_CONF, new byte[0], existsPolicy); zoo.putPersistentData(zTablePath + Constants.ZTABLE_NAMESPACE, namespaceId.getUtf8(), existsPolicy); zoo.putPersistentData(zTablePath + Constants.ZTABLE_NAME, tableName.getBytes(UTF_8), existsPolicy); zoo.putPersistentData(zTablePath + Constants.ZTABLE_FLUSH_ID, ZERO_BYTE, existsPolicy); zoo.putPersistentData(zTablePath + Constants.ZTABLE_COMPACT_ID, ZERO_BYTE, existsPolicy); zoo.putPersistentData(zTablePath + Constants.ZTABLE_COMPACT_CANCEL_ID, ZERO_BYTE, existsPolicy); zoo.putPersistentData(zTablePath + Constants.ZTABLE_STATE, state.name().getBytes(UTF_8), existsPolicy); }
@Override public Repo<Master> call(long tid, Master env) throws Exception { // reserve the table name in zookeeper or fail Utils.getTableNameLock().lock(); try { // write tableName & tableId to zookeeper Utils.checkTableDoesNotExist(env.getContext(), tableInfo.tableName, tableInfo.tableId, TableOperation.CREATE); String namespace = Tables.qualify(tableInfo.tableName).getFirst(); Namespace.ID namespaceId = Namespaces.getNamespaceId(env.getContext(), namespace); env.getTableManager().addTable(tableInfo.tableId, namespaceId, tableInfo.tableName, NodeExistsPolicy.OVERWRITE); Tables.clearCache(env.getContext()); } finally { Utils.getTableNameLock().unlock(); } for (Entry<String,String> entry : getExportedProps(env.getFileSystem()).entrySet()) if (!TablePropUtil.setTableProperty(env.getContext(), tableInfo.tableId, entry.getKey(), entry.getValue())) { throw new AcceptableThriftTableOperationException(tableInfo.tableId.canonicalID(), tableInfo.tableName, TableOperation.IMPORT, TableOperationExceptionType.OTHER, "Invalid table property " + entry.getKey()); } return new CreateImportDir(tableInfo); }
MetadataTable.ID, MetadataTable.NAME); zoo.putPersistentData(tables + "/" + MetadataTable.ID + Constants.ZTABLE_NAME, Tables.qualify(MetadataTable.NAME).getSecond().getBytes(UTF_8), NodeExistsPolicy.OVERWRITE);
Tables.qualify(tableName).getFirst()); } catch (NamespaceNotFoundException e) { throw new ThriftTableOperationException(null, tableName, tableOp, try { namespaceId = Namespaces.getNamespaceId(master.getContext(), Tables.qualify(tableName).getFirst()); } catch (NamespaceNotFoundException e) { try { namespaceId = Namespaces.getNamespaceId(master.getContext(), Tables.qualify(tableName).getFirst()); } catch (NamespaceNotFoundException e) { throw new ThriftTableOperationException(null, tableName, tableOp,