Example 1 with CancelCompactions
use of org.apache.accumulo.manager.tableOps.compact.cancel.CancelCompactions in project accumulo by apache.
the class FateServiceHandler method executeFateOperation.
@Override
public void executeFateOperation(TInfo tinfo, TCredentials c, long opid, FateOperation op, List<ByteBuffer> arguments, Map<String, String> options, boolean autoCleanup) throws ThriftSecurityException, ThriftTableOperationException {
authenticate(c);
String goalMessage = op.toString() + " ";
switch(op) {
case NAMESPACE_CREATE:
{
TableOperation tableOp = TableOperation.CREATE;
validateArgumentCount(arguments, tableOp, 1);
String namespace = validateName(arguments.get(0), tableOp, NEW_NAMESPACE_NAME);
if (!manager.security.canCreateNamespace(c))
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Create " + namespace + " namespace.";
manager.fate.seedTransaction(opid, new TraceRepo<>(new CreateNamespace(c.getPrincipal(), namespace, options)), autoCleanup, goalMessage);
break;
}
case NAMESPACE_RENAME:
{
TableOperation tableOp = TableOperation.RENAME;
validateArgumentCount(arguments, tableOp, 2);
String oldName = validateName(arguments.get(0), tableOp, EXISTING_NAMESPACE_NAME.and(NOT_BUILTIN_NAMESPACE));
String newName = validateName(arguments.get(1), tableOp, NEW_NAMESPACE_NAME);
NamespaceId namespaceId = ClientServiceHandler.checkNamespaceId(manager.getContext(), oldName, tableOp);
if (!manager.security.canRenameNamespace(c, namespaceId))
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Rename " + oldName + " namespace to " + newName;
manager.fate.seedTransaction(opid, new TraceRepo<>(new RenameNamespace(namespaceId, oldName, newName)), autoCleanup, goalMessage);
break;
}
case NAMESPACE_DELETE:
{
TableOperation tableOp = TableOperation.DELETE;
validateArgumentCount(arguments, tableOp, 1);
String namespace = validateName(arguments.get(0), tableOp, EXISTING_NAMESPACE_NAME.and(NOT_BUILTIN_NAMESPACE));
NamespaceId namespaceId = ClientServiceHandler.checkNamespaceId(manager.getContext(), namespace, tableOp);
if (!manager.security.canDeleteNamespace(c, namespaceId))
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Delete namespace Id: " + namespaceId;
manager.fate.seedTransaction(opid, new TraceRepo<>(new DeleteNamespace(namespaceId)), autoCleanup, goalMessage);
break;
}
case TABLE_CREATE:
{
TableOperation tableOp = TableOperation.CREATE;
// offset where split data begins in arguments list
int SPLIT_OFFSET = 4;
if (arguments.size() < SPLIT_OFFSET) {
throw new ThriftTableOperationException(null, null, tableOp, TableOperationExceptionType.OTHER, "Expected at least " + SPLIT_OFFSET + " arguments, saw :" + arguments.size());
}
String tableName = validateName(arguments.get(0), tableOp, NEW_TABLE_NAME.and(NOT_BUILTIN_TABLE));
TimeType timeType = TimeType.valueOf(ByteBufferUtil.toString(arguments.get(1)));
InitialTableState initialTableState = InitialTableState.valueOf(ByteBufferUtil.toString(arguments.get(2)));
int splitCount = Integer.parseInt(ByteBufferUtil.toString(arguments.get(3)));
validateArgumentCount(arguments, tableOp, SPLIT_OFFSET + splitCount);
Path splitsPath = null;
Path splitsDirsPath = null;
if (splitCount > 0) {
try {
Path tmpDir = mkTempDir(opid);
splitsPath = new Path(tmpDir, "splits");
splitsDirsPath = new Path(tmpDir, "splitsDirs");
writeSplitsToFile(splitsPath, arguments, splitCount, SPLIT_OFFSET);
} catch (IOException e) {
throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.OTHER, "Exception thrown while writing splits to file system");
}
}
NamespaceId namespaceId;
try {
namespaceId = Namespaces.getNamespaceId(manager.getContext(), TableNameUtil.qualify(tableName).getFirst());
} catch (NamespaceNotFoundException e) {
throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.NAMESPACE_NOTFOUND, "");
}
if (!manager.security.canCreateTable(c, tableName, namespaceId))
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
for (Map.Entry<String, String> entry : options.entrySet()) {
if (!Property.isTablePropertyValid(entry.getKey(), entry.getValue())) {
throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.OTHER, "Property or value not valid " + entry.getKey() + "=" + entry.getValue());
}
}
goalMessage += "Create table " + tableName + " " + initialTableState + " with " + splitCount + " splits.";
manager.fate.seedTransaction(opid, new TraceRepo<>(new CreateTable(c.getPrincipal(), tableName, timeType, options, splitsPath, splitCount, splitsDirsPath, initialTableState, namespaceId)), autoCleanup, goalMessage);
break;
}
case TABLE_RENAME:
{
TableOperation tableOp = TableOperation.RENAME;
validateArgumentCount(arguments, tableOp, 2);
String oldTableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_BUILTIN_TABLE));
String newTableName = validateName(arguments.get(1), tableOp, NEW_TABLE_NAME.and(sameNamespaceAs(oldTableName)));
TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), oldTableName, tableOp);
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canRename;
try {
canRename = manager.security.canRenameTable(c, tableId, oldTableName, newTableName, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, oldTableName, TableOperation.RENAME);
throw e;
}
if (!canRename)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Rename table " + oldTableName + "(" + tableId + ") to " + oldTableName;
try {
manager.fate.seedTransaction(opid, new TraceRepo<>(new RenameTable(namespaceId, tableId, oldTableName, newTableName)), autoCleanup, goalMessage);
} catch (NamespaceNotFoundException e) {
throw new ThriftTableOperationException(null, oldTableName, tableOp, TableOperationExceptionType.NAMESPACE_NOTFOUND, "");
}
break;
}
case TABLE_CLONE:
{
TableOperation tableOp = TableOperation.CLONE;
validateArgumentCount(arguments, tableOp, 3);
TableId srcTableId = validateTableIdArgument(arguments.get(0), tableOp, CAN_CLONE_TABLE);
String tableName = validateName(arguments.get(1), tableOp, NEW_TABLE_NAME.and(NOT_BUILTIN_TABLE));
boolean keepOffline = false;
if (arguments.get(2) != null) {
keepOffline = Boolean.parseBoolean(ByteBufferUtil.toString(arguments.get(2)));
}
NamespaceId namespaceId;
try {
namespaceId = Namespaces.getNamespaceId(manager.getContext(), TableNameUtil.qualify(tableName).getFirst());
} catch (NamespaceNotFoundException e) {
// shouldn't happen, but possible once cloning between namespaces is supported
throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.NAMESPACE_NOTFOUND, "");
}
final boolean canCloneTable;
try {
canCloneTable = manager.security.canCloneTable(c, srcTableId, tableName, namespaceId, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, srcTableId, null, TableOperation.CLONE);
throw e;
}
if (!canCloneTable)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
Map<String, String> propertiesToSet = new HashMap<>();
Set<String> propertiesToExclude = new HashSet<>();
for (Entry<String, String> entry : options.entrySet()) {
if (entry.getKey().startsWith(TableOperationsImpl.CLONE_EXCLUDE_PREFIX)) {
propertiesToExclude.add(entry.getKey().substring(TableOperationsImpl.CLONE_EXCLUDE_PREFIX.length()));
continue;
}
if (!Property.isTablePropertyValid(entry.getKey(), entry.getValue())) {
throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.OTHER, "Property or value not valid " + entry.getKey() + "=" + entry.getValue());
}
propertiesToSet.put(entry.getKey(), entry.getValue());
}
goalMessage += "Clone table " + srcTableId + " to " + tableName;
if (keepOffline)
goalMessage += " and keep offline.";
manager.fate.seedTransaction(opid, new TraceRepo<>(new CloneTable(c.getPrincipal(), namespaceId, srcTableId, tableName, propertiesToSet, propertiesToExclude, keepOffline)), autoCleanup, goalMessage);
break;
}
case TABLE_DELETE:
{
TableOperation tableOp = TableOperation.DELETE;
validateArgumentCount(arguments, tableOp, 1);
String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_BUILTIN_TABLE));
final TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canDeleteTable;
try {
canDeleteTable = manager.security.canDeleteTable(c, tableId, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.DELETE);
throw e;
}
if (!canDeleteTable)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Delete table " + tableName + "(" + tableId + ")";
manager.fate.seedTransaction(opid, new TraceRepo<>(new PreDeleteTable(namespaceId, tableId)), autoCleanup, goalMessage);
break;
}
case TABLE_ONLINE:
{
TableOperation tableOp = TableOperation.ONLINE;
validateArgumentCount(arguments, tableOp, 1);
final var tableId = validateTableIdArgument(arguments.get(0), tableOp, NOT_ROOT_TABLE_ID);
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canOnlineOfflineTable;
try {
canOnlineOfflineTable = manager.security.canOnlineOfflineTable(c, tableId, op, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, null, TableOperation.ONLINE);
throw e;
}
if (!canOnlineOfflineTable)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Online table " + tableId;
manager.fate.seedTransaction(opid, new TraceRepo<>(new ChangeTableState(namespaceId, tableId, tableOp)), autoCleanup, goalMessage);
break;
}
case TABLE_OFFLINE:
{
TableOperation tableOp = TableOperation.OFFLINE;
validateArgumentCount(arguments, tableOp, 1);
final var tableId = validateTableIdArgument(arguments.get(0), tableOp, NOT_ROOT_TABLE_ID);
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canOnlineOfflineTable;
try {
canOnlineOfflineTable = manager.security.canOnlineOfflineTable(c, tableId, op, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, null, TableOperation.OFFLINE);
throw e;
}
if (!canOnlineOfflineTable)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Offline table " + tableId;
manager.fate.seedTransaction(opid, new TraceRepo<>(new ChangeTableState(namespaceId, tableId, tableOp)), autoCleanup, goalMessage);
break;
}
case TABLE_MERGE:
{
TableOperation tableOp = TableOperation.MERGE;
validateArgumentCount(arguments, tableOp, 3);
String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME);
Text startRow = ByteBufferUtil.toText(arguments.get(1));
Text endRow = ByteBufferUtil.toText(arguments.get(2));
final TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canMerge;
try {
canMerge = manager.security.canMerge(c, tableId, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.MERGE);
throw e;
}
if (!canMerge)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
Manager.log.debug("Creating merge op: {} {} {}", tableId, startRow, endRow);
goalMessage += "Merge table " + tableName + "(" + tableId + ") splits from " + startRow + " to " + endRow;
manager.fate.seedTransaction(opid, new TraceRepo<>(new TableRangeOp(MergeInfo.Operation.MERGE, namespaceId, tableId, startRow, endRow)), autoCleanup, goalMessage);
break;
}
case TABLE_DELETE_RANGE:
{
TableOperation tableOp = TableOperation.DELETE_RANGE;
validateArgumentCount(arguments, tableOp, 3);
String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_METADATA_TABLE));
Text startRow = ByteBufferUtil.toText(arguments.get(1));
Text endRow = ByteBufferUtil.toText(arguments.get(2));
final TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canDeleteRange;
try {
canDeleteRange = manager.security.canDeleteRange(c, tableId, tableName, startRow, endRow, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.DELETE_RANGE);
throw e;
}
if (!canDeleteRange)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Delete table " + tableName + "(" + tableId + ") range " + startRow + " to " + endRow;
manager.fate.seedTransaction(opid, new TraceRepo<>(new TableRangeOp(MergeInfo.Operation.DELETE, namespaceId, tableId, startRow, endRow)), autoCleanup, goalMessage);
break;
}
case TABLE_BULK_IMPORT:
{
TableOperation tableOp = TableOperation.BULK_IMPORT;
validateArgumentCount(arguments, tableOp, 4);
String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_BUILTIN_TABLE));
String dir = ByteBufferUtil.toString(arguments.get(1));
String failDir = ByteBufferUtil.toString(arguments.get(2));
boolean setTime = Boolean.parseBoolean(ByteBufferUtil.toString(arguments.get(3)));
final TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canBulkImport;
try {
canBulkImport = manager.security.canBulkImport(c, tableId, tableName, dir, failDir, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.BULK_IMPORT);
throw e;
}
if (!canBulkImport)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
manager.updateBulkImportStatus(dir, BulkImportState.INITIAL);
goalMessage += "Bulk import " + dir + " to " + tableName + "(" + tableId + ") failing to " + failDir;
manager.fate.seedTransaction(opid, new TraceRepo<>(new org.apache.accumulo.manager.tableOps.bulkVer1.BulkImport(tableId, dir, failDir, setTime)), autoCleanup, goalMessage);
break;
}
case TABLE_COMPACT:
{
TableOperation tableOp = TableOperation.COMPACT;
validateArgumentCount(arguments, tableOp, 2);
TableId tableId = validateTableIdArgument(arguments.get(0), tableOp, null);
CompactionConfig compactionConfig = UserCompactionUtils.decodeCompactionConfig(ByteBufferUtil.toBytes(arguments.get(1)));
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canCompact;
try {
canCompact = manager.security.canCompact(c, tableId, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, null, TableOperation.COMPACT);
throw e;
}
if (!canCompact)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Compact table (" + tableId + ") with config " + compactionConfig;
manager.fate.seedTransaction(opid, new TraceRepo<>(new CompactRange(namespaceId, tableId, compactionConfig)), autoCleanup, goalMessage);
break;
}
case TABLE_CANCEL_COMPACT:
{
TableOperation tableOp = TableOperation.COMPACT_CANCEL;
validateArgumentCount(arguments, tableOp, 1);
TableId tableId = validateTableIdArgument(arguments.get(0), tableOp, null);
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canCancelCompact;
try {
canCancelCompact = manager.security.canCompact(c, tableId, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, null, TableOperation.COMPACT_CANCEL);
throw e;
}
if (!canCancelCompact)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Cancel compaction of table (" + tableId + ")";
manager.fate.seedTransaction(opid, new TraceRepo<>(new CancelCompactions(namespaceId, tableId)), autoCleanup, goalMessage);
break;
}
case TABLE_IMPORT:
{
TableOperation tableOp = TableOperation.IMPORT;
// offset where table list begins
int IMPORT_DIR_OFFSET = 2;
if (arguments.size() < IMPORT_DIR_OFFSET) {
throw new ThriftTableOperationException(null, null, tableOp, TableOperationExceptionType.OTHER, "Expected at least " + IMPORT_DIR_OFFSET + "arguments, sar :" + arguments.size());
}
String tableName = validateName(arguments.get(0), tableOp, NEW_TABLE_NAME.and(NOT_BUILTIN_TABLE));
List<ByteBuffer> exportDirArgs = arguments.stream().skip(1).collect(Collectors.toList());
Set<String> exportDirs = ByteBufferUtil.toStringSet(exportDirArgs);
NamespaceId namespaceId;
try {
namespaceId = Namespaces.getNamespaceId(manager.getContext(), TableNameUtil.qualify(tableName).getFirst());
} catch (NamespaceNotFoundException e) {
throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.NAMESPACE_NOTFOUND, "");
}
final boolean canImport;
try {
canImport = manager.security.canImport(c, tableName, exportDirs, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, null, tableName, TableOperation.IMPORT);
throw e;
}
if (!canImport)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Import table with new name: " + tableName + " from " + exportDirs;
manager.fate.seedTransaction(opid, new TraceRepo<>(new ImportTable(c.getPrincipal(), tableName, exportDirs, namespaceId)), autoCleanup, goalMessage);
break;
}
case TABLE_EXPORT:
{
TableOperation tableOp = TableOperation.EXPORT;
validateArgumentCount(arguments, tableOp, 2);
String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_BUILTIN_TABLE));
String exportDir = ByteBufferUtil.toString(arguments.get(1));
TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canExport;
try {
canExport = manager.security.canExport(c, tableId, tableName, exportDir, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.EXPORT);
throw e;
}
if (!canExport)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
goalMessage += "Export table " + tableName + "(" + tableId + ") to " + exportDir;
manager.fate.seedTransaction(opid, new TraceRepo<>(new ExportTable(namespaceId, tableName, tableId, exportDir)), autoCleanup, goalMessage);
break;
}
case TABLE_BULK_IMPORT2:
TableOperation tableOp = TableOperation.BULK_IMPORT;
validateArgumentCount(arguments, tableOp, 3);
final var tableId = validateTableIdArgument(arguments.get(0), tableOp, NOT_ROOT_TABLE_ID);
String dir = ByteBufferUtil.toString(arguments.get(1));
boolean setTime = Boolean.parseBoolean(ByteBufferUtil.toString(arguments.get(2)));
NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
final boolean canBulkImport;
String tableName;
try {
tableName = manager.getContext().getTableName(tableId);
canBulkImport = manager.security.canBulkImport(c, tableId, tableName, dir, null, namespaceId);
} catch (ThriftSecurityException e) {
throwIfTableMissingSecurityException(e, tableId, "", TableOperation.BULK_IMPORT);
throw e;
} catch (TableNotFoundException e) {
throw new ThriftTableOperationException(tableId.canonical(), null, TableOperation.BULK_IMPORT, TableOperationExceptionType.NOTFOUND, "Table no longer exists");
}
if (!canBulkImport)
throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
manager.updateBulkImportStatus(dir, BulkImportState.INITIAL);
goalMessage += "Bulk import (v2) " + dir + " to " + tableName + "(" + tableId + ")";
manager.fate.seedTransaction(opid, new TraceRepo<>(new PrepBulkImport(tableId, dir, setTime)), autoCleanup, goalMessage);
break;
default:
throw new UnsupportedOperationException();
}
}
Also used :
TableId(org.apache.accumulo.core.data.TableId)
Set(java.util.Set)
HashSet(java.util.HashSet)
ChangeTableState(org.apache.accumulo.manager.tableOps.ChangeTableState)
DeleteNamespace(org.apache.accumulo.manager.tableOps.namespace.delete.DeleteNamespace)
PreDeleteTable(org.apache.accumulo.manager.tableOps.delete.PreDeleteTable)
PrepBulkImport(org.apache.accumulo.manager.tableOps.bulkVer2.PrepBulkImport)
InitialTableState(org.apache.accumulo.core.client.admin.InitialTableState)
CreateTable(org.apache.accumulo.manager.tableOps.create.CreateTable)
RenameNamespace(org.apache.accumulo.manager.tableOps.namespace.rename.RenameNamespace)
TimeType(org.apache.accumulo.core.client.admin.TimeType)
CancelCompactions(org.apache.accumulo.manager.tableOps.compact.cancel.CancelCompactions)
TableNotFoundException(org.apache.accumulo.core.client.TableNotFoundException)
Entry(java.util.Map.Entry)
CompactionConfig(org.apache.accumulo.core.client.admin.CompactionConfig)
ThriftTableOperationException(org.apache.accumulo.core.clientImpl.thrift.ThriftTableOperationException)
List(java.util.List)
ImportTable(org.apache.accumulo.manager.tableOps.tableImport.ImportTable)
CloneTable(org.apache.accumulo.manager.tableOps.clone.CloneTable)
Path(org.apache.hadoop.fs.Path)
CompactRange(org.apache.accumulo.manager.tableOps.compact.CompactRange)
Text(org.apache.hadoop.io.Text)
TraceRepo(org.apache.accumulo.manager.tableOps.TraceRepo)
IOException(java.io.IOException)
ThriftSecurityException(org.apache.accumulo.core.clientImpl.thrift.ThriftSecurityException)
NamespaceNotFoundException(org.apache.accumulo.core.client.NamespaceNotFoundException)
ExportTable(org.apache.accumulo.manager.tableOps.tableExport.ExportTable)
RenameTable(org.apache.accumulo.manager.tableOps.rename.RenameTable)
TableOperation(org.apache.accumulo.core.clientImpl.thrift.TableOperation)
TableRangeOp(org.apache.accumulo.manager.tableOps.merge.TableRangeOp)
NamespaceId(org.apache.accumulo.core.data.NamespaceId)
Map(java.util.Map)
HashMap(java.util.HashMap)
CreateNamespace(org.apache.accumulo.manager.tableOps.namespace.create.CreateNamespace)
Aggregations
IOException (java.io.IOException)1
HashMap (java.util.HashMap)1
HashSet (java.util.HashSet)1
List (java.util.List)1
Map (java.util.Map)1
Entry (java.util.Map.Entry)1
Set (java.util.Set)1
NamespaceNotFoundException (org.apache.accumulo.core.client.NamespaceNotFoundException)1
TableNotFoundException (org.apache.accumulo.core.client.TableNotFoundException)1
CompactionConfig (org.apache.accumulo.core.client.admin.CompactionConfig)1
InitialTableState (org.apache.accumulo.core.client.admin.InitialTableState)1
TimeType (org.apache.accumulo.core.client.admin.TimeType)1
TableOperation (org.apache.accumulo.core.clientImpl.thrift.TableOperation)1
ThriftSecurityException (org.apache.accumulo.core.clientImpl.thrift.ThriftSecurityException)1
ThriftTableOperationException (org.apache.accumulo.core.clientImpl.thrift.ThriftTableOperationException)1
NamespaceId (org.apache.accumulo.core.data.NamespaceId)1
TableId (org.apache.accumulo.core.data.TableId)1
ChangeTableState (org.apache.accumulo.manager.tableOps.ChangeTableState)1
TraceRepo (org.apache.accumulo.manager.tableOps.TraceRepo)1
PrepBulkImport (org.apache.accumulo.manager.tableOps.bulkVer2.PrepBulkImport)1
