public void addMigration(KeyExtent tablet, Runnable migrationHandler) {
if (tablet.isRootTablet()) {
migrationHandler.run();
} else if (tablet.isMeta()) {
defaultMigrationPool.execute(migrationHandler);
} else {
migrationPool.execute(migrationHandler);
}
}
public void executeMajorCompaction(KeyExtent tablet, Runnable compactionTask) {
if (tablet.isRootTablet()) {
rootMajorCompactionThreadPool.execute(compactionTask);
} else if (tablet.isMeta()) {
defaultMajorCompactionThreadPool.execute(compactionTask);
} else {
majorCompactionThreadPool.execute(compactionTask);
}
}
public void executeReadAhead(KeyExtent tablet, Runnable task) {
if (tablet.isRootTablet()) {
task.run();
} else if (tablet.isMeta()) {
defaultReadAheadThreadPool.execute(task);
} else {
readAheadThreadPool.execute(task);
}
}
public void executeSplit(KeyExtent tablet, Runnable splitTask) {
if (tablet.isMeta()) {
if (tablet.isRootTablet()) {
log.warn("Saw request to split root tablet, ignoring");
return;
}
defaultSplitThreadPool.execute(splitTask);
} else {
splitThreadPool.execute(splitTask);
}
}
public static boolean getBatchFromServer(
ClientContext context,
Range range,
KeyExtent extent,
String server,
SortedMap<Key, Value> results,
SortedSet<Column> fetchedColumns,
List<IterInfo> serverSideIteratorList,
Map<String, Map<String, String>> serverSideIteratorOptions,
int size,
Authorizations authorizations,
boolean retry,
long batchTimeOut,
String classLoaderContext)
throws AccumuloException, AccumuloSecurityException, NotServingTabletException {
if (server == null) throw new AccumuloException(new IOException());
final HostAndPort parsedServer = HostAndPort.fromString(server);
try {
TInfo tinfo = Tracer.traceInfo();
TabletClientService.Client client = ThriftUtil.getTServerClient(parsedServer, context);
try {
// not reading whole rows (or stopping on row boundries) so there is no need to enable
// isolation below
ScanState scanState =
new ScanState(
context,
extent.getTableId(),
authorizations,
range,
fetchedColumns,
size,
serverSideIteratorList,
serverSideIteratorOptions,
false,
Constants.SCANNER_DEFAULT_READAHEAD_THRESHOLD,
null,
batchTimeOut,
classLoaderContext);
TabletType ttype = TabletType.type(extent);
boolean waitForWrites = !serversWaitedForWrites.get(ttype).contains(server);
InitialScan isr =
client.startScan(
tinfo,
scanState.context.rpcCreds(),
extent.toThrift(),
scanState.range.toThrift(),
Translator.translate(scanState.columns, Translators.CT),
scanState.size,
scanState.serverSideIteratorList,
scanState.serverSideIteratorOptions,
scanState.authorizations.getAuthorizationsBB(),
waitForWrites,
scanState.isolated,
scanState.readaheadThreshold,
null,
scanState.batchTimeOut,
classLoaderContext);
if (waitForWrites) serversWaitedForWrites.get(ttype).add(server);
Key.decompress(isr.result.results);
for (TKeyValue kv : isr.result.results) results.put(new Key(kv.key), new Value(kv.value));
client.closeScan(tinfo, isr.scanID);
return isr.result.more;
} finally {
ThriftUtil.returnClient(client);
}
} catch (TApplicationException tae) {
throw new AccumuloServerException(server, tae);
} catch (TooManyFilesException e) {
log.debug("Tablet ({}) has too many files {} : {}", extent, server, e.getMessage());
} catch (ThriftSecurityException e) {
log.warn("Security Violation in scan request to {}: {}", server, e.getMessage());
throw new AccumuloSecurityException(e.user, e.code, e);
} catch (TException e) {
log.debug("Error getting transport to {}: {}", server, e.getMessage());
}
throw new AccumuloException("getBatchFromServer: failed");
}