org.apache.hadoop.hbase.client

Class AsyncNonMetaRegionLocator

java.lang.Object

org.apache.hadoop.hbase.client.AsyncNonMetaRegionLocator

@InterfaceAudience.Private
class AsyncNonMetaRegionLocator
extends Object

The asynchronous locator for regions other than meta.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	AsyncNonMetaRegionLocator.LocateRequest
private static class	AsyncNonMetaRegionLocator.RegionLocationsFutureResult
private static class	AsyncNonMetaRegionLocator.TableCache

Field Summary

Fields

Modifier and Type	Field and Description
private ConcurrentMap<TableName,AsyncNonMetaRegionLocator.TableCache>	cache
private AsyncConnectionImpl	conn
private static int	DEFAULT_LOCATE_PREFETCH_LIMIT
private static int	DEFAULT_MAX_CONCURRENT_LOCATE_REQUEST_PER_TABLE
(package private) static String	LOCATE_PREFETCH_LIMIT
private int	locatePrefetchLimit
private static org.slf4j.Logger	LOG
(package private) static String	MAX_CONCURRENT_LOCATE_REQUEST_PER_TABLE
private int	maxConcurrentLocateRequestPerTable
private CatalogReplicaMode	metaReplicaMode
private CatalogReplicaLoadBalanceSelector	metaReplicaSelector

Constructor Summary

Constructors

Constructor and Description
AsyncNonMetaRegionLocator(AsyncConnectionImpl conn)

Method Summary

Modifier and Type	Method and Description
(package private) void	addLocationToCache(HRegionLocation loc)
private RegionLocations	addToCache(AsyncNonMetaRegionLocator.TableCache tableCache, RegionLocations locs)
(package private) void	clearCache()
(package private) void	clearCache(ServerName serverName)
(package private) void	clearCache(TableName tableName)
private void	complete(TableName tableName, AsyncNonMetaRegionLocator.LocateRequest req, RegionLocations locs, Throwable error)
private HRegionLocation	getCachedLocation(HRegionLocation loc)
(package private) RegionLocations	getRegionLocationInCache(TableName tableName, byte[] row)
(package private) CompletableFuture<RegionLocations>	getRegionLocations(TableName tableName, byte[] row, int replicaId, RegionLocateType locateType, boolean reload)
private CompletableFuture<RegionLocations>	getRegionLocationsInternal(TableName tableName, byte[] row, int replicaId, RegionLocateType locateType, boolean reload)
private AsyncNonMetaRegionLocator.TableCache	getTableCache(TableName tableName)
private boolean	isEqual(RegionLocations locs1, RegionLocations locs2)
private RegionLocations	locateInCache(AsyncNonMetaRegionLocator.TableCache tableCache, TableName tableName, byte[] row, int replicaId, RegionLocateType locateType)
private void	locateInMeta(TableName tableName, AsyncNonMetaRegionLocator.LocateRequest req)
private RegionLocations	locateRowBeforeInCache(AsyncNonMetaRegionLocator.TableCache tableCache, TableName tableName, byte[] row, int replicaId)
private RegionLocations	locateRowInCache(AsyncNonMetaRegionLocator.TableCache tableCache, TableName tableName, byte[] row, int replicaId)
private boolean	onScanNext(TableName tableName, AsyncNonMetaRegionLocator.LocateRequest req, Result result)
private void	recordCacheHit()
private void	recordCacheMiss()
private void	recordClearRegionCache()
private void	removeLocationFromCache(HRegionLocation loc)
(package private) void	updateCachedLocationOnError(HRegionLocation loc, Throwable exception)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOG

private static final org.slf4j.Logger LOG

MAX_CONCURRENT_LOCATE_REQUEST_PER_TABLE

static final String MAX_CONCURRENT_LOCATE_REQUEST_PER_TABLE

See Also:

Constant Field Values

DEFAULT_MAX_CONCURRENT_LOCATE_REQUEST_PER_TABLE

private static final int DEFAULT_MAX_CONCURRENT_LOCATE_REQUEST_PER_TABLE

See Also:

Constant Field Values

LOCATE_PREFETCH_LIMIT

static String LOCATE_PREFETCH_LIMIT

DEFAULT_LOCATE_PREFETCH_LIMIT

private static final int DEFAULT_LOCATE_PREFETCH_LIMIT

See Also:

Constant Field Values

conn

private final AsyncConnectionImpl conn

maxConcurrentLocateRequestPerTable

private final int maxConcurrentLocateRequestPerTable

locatePrefetchLimit

private final int locatePrefetchLimit

metaReplicaMode

private CatalogReplicaMode metaReplicaMode

metaReplicaSelector

private CatalogReplicaLoadBalanceSelector metaReplicaSelector

cache

private final ConcurrentMap<TableName,AsyncNonMetaRegionLocator.TableCache> cache

Constructor Detail

AsyncNonMetaRegionLocator

AsyncNonMetaRegionLocator(AsyncConnectionImpl conn)

Method Detail

getTableCache

private AsyncNonMetaRegionLocator.TableCache getTableCache(TableName tableName)

isEqual

private boolean isEqual(RegionLocations locs1,
                        RegionLocations locs2)

addToCache

private RegionLocations addToCache(AsyncNonMetaRegionLocator.TableCache tableCache,
                                   RegionLocations locs)

complete

private void complete(TableName tableName,
                      AsyncNonMetaRegionLocator.LocateRequest req,
                      RegionLocations locs,
                      Throwable error)

onScanNext

private boolean onScanNext(TableName tableName,
                           AsyncNonMetaRegionLocator.LocateRequest req,
                           Result result)

recordCacheHit

private void recordCacheHit()

recordCacheMiss

private void recordCacheMiss()

locateRowInCache

private RegionLocations locateRowInCache(AsyncNonMetaRegionLocator.TableCache tableCache,
                                         TableName tableName,
                                         byte[] row,
                                         int replicaId)

locateRowBeforeInCache

private RegionLocations locateRowBeforeInCache(AsyncNonMetaRegionLocator.TableCache tableCache,
                                               TableName tableName,
                                               byte[] row,
                                               int replicaId)

locateInMeta

private void locateInMeta(TableName tableName,
                          AsyncNonMetaRegionLocator.LocateRequest req)

locateInCache

private RegionLocations locateInCache(AsyncNonMetaRegionLocator.TableCache tableCache,
                                      TableName tableName,
                                      byte[] row,
                                      int replicaId,
                                      RegionLocateType locateType)

getRegionLocationsInternal

private CompletableFuture<RegionLocations> getRegionLocationsInternal(TableName tableName,
                                                                      byte[] row,
                                                                      int replicaId,
                                                                      RegionLocateType locateType,
                                                                      boolean reload)

getRegionLocations

CompletableFuture<RegionLocations> getRegionLocations(TableName tableName,
                                                      byte[] row,
                                                      int replicaId,
                                                      RegionLocateType locateType,
                                                      boolean reload)

recordClearRegionCache

private void recordClearRegionCache()

removeLocationFromCache

private void removeLocationFromCache(HRegionLocation loc)

addLocationToCache

void addLocationToCache(HRegionLocation loc)

getCachedLocation

private HRegionLocation getCachedLocation(HRegionLocation loc)

updateCachedLocationOnError

void updateCachedLocationOnError(HRegionLocation loc,
                                 Throwable exception)

clearCache

void clearCache(TableName tableName)

clearCache

void clearCache()

clearCache

void clearCache(ServerName serverName)

getRegionLocationInCache

RegionLocations getRegionLocationInCache(TableName tableName,
                                         byte[] row)