| Modifier and Type | Field and Description |
|---|---|
private ServerName |
ClusterMetricsBuilder.masterName |
private ServerName |
ClusterMetricsBuilder.ClusterMetricsImpl.masterName |
private ServerName |
SplitLogTask.originServer |
private ServerName |
HRegionLocation.serverName |
private ServerName |
ServerMetricsBuilder.serverName |
private ServerName |
ServerMetricsBuilder.ServerMetricsImpl.serverName |
| Modifier and Type | Field and Description |
|---|---|
private List<ServerName> |
ClusterMetricsBuilder.backupMasterNames |
private List<ServerName> |
ClusterMetricsBuilder.ClusterMetricsImpl.backupMasterNames |
private List<ServerName> |
ClusterMetricsBuilder.deadServerNames |
private List<ServerName> |
ClusterMetricsBuilder.ClusterMetricsImpl.deadServerNames |
static List<ServerName> |
ServerName.EMPTY_SERVER_LIST |
private static org.apache.hbase.thirdparty.com.google.common.collect.Interner<ServerName> |
ServerName.INTERN_POOL
Intern ServerNames.
|
private Map<ServerName,ServerMetrics> |
ClusterMetricsBuilder.liveServerMetrics |
private Map<ServerName,ServerMetrics> |
ClusterMetricsBuilder.ClusterMetricsImpl.liveServerMetrics |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
ClusterStatus.getMaster()
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
Use
ClusterStatus.getMasterName() instead. |
ServerName |
ClusterStatus.getMasterName()
Deprecated.
|
ServerName |
ClusterMetrics.getMasterName()
Returns detailed information about the current master
ServerName. |
ServerName |
ClusterMetricsBuilder.ClusterMetricsImpl.getMasterName() |
ServerName |
ServerMetrics.getServerName() |
ServerName |
ServerLoad.getServerName()
Deprecated.
|
ServerName |
HRegionLocation.getServerName() |
ServerName |
ServerMetricsBuilder.ServerMetricsImpl.getServerName() |
ServerName |
SplitLogTask.getServerName() |
ServerName |
Server.getServerName() |
static ServerName |
MetaTableAccessor.getServerName(Result r,
int replicaId)
Returns a
ServerName from catalog table Result. |
static ServerName |
ServerName.parseServerName(String str) |
static ServerName |
ServerName.parseVersionedServerName(byte[] versionedBytes)
Use this method instantiating a
ServerName from bytes
gotten from a call to getVersionedBytes(). |
static ServerName |
ServerName.valueOf(String serverName)
Retrieve an instance of ServerName.
|
static ServerName |
ServerName.valueOf(String hostname,
int port,
long startcode)
Retrieve an instance of ServerName.
|
static ServerName |
ServerName.valueOf(String hostAndPort,
long startCode)
Retrieve an instance of ServerName.
|
| Modifier and Type | Method and Description |
|---|---|
static NavigableMap<RegionInfo,ServerName> |
MetaTableAccessor.allTableRegions(Connection connection,
TableName tableName)
Deprecated.
use
MetaTableAccessor.getTableRegionsAndLocations(org.apache.hadoop.hbase.client.Connection, org.apache.hadoop.hbase.TableName), region can have multiple locations |
List<ServerName> |
ClusterStatus.getBackupMasterNames()
Deprecated.
|
List<ServerName> |
ClusterMetrics.getBackupMasterNames() |
List<ServerName> |
ClusterMetricsBuilder.ClusterMetricsImpl.getBackupMasterNames() |
List<ServerName> |
ClusterStatus.getBackupMasters()
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
Use
ClusterStatus.getBackupMasterNames() instead. |
List<ServerName> |
ClusterStatus.getDeadServerNames()
Deprecated.
|
List<ServerName> |
ClusterMetrics.getDeadServerNames() |
List<ServerName> |
ClusterMetricsBuilder.ClusterMetricsImpl.getDeadServerNames() |
private Map<ServerName,ServerLoad> |
ClusterStatus.getLiveServerLoads()
Deprecated.
|
Map<ServerName,ServerMetrics> |
ClusterStatus.getLiveServerMetrics()
Deprecated.
|
Map<ServerName,ServerMetrics> |
ClusterMetrics.getLiveServerMetrics() |
Map<ServerName,ServerMetrics> |
ClusterMetricsBuilder.ClusterMetricsImpl.getLiveServerMetrics() |
static Pair<RegionInfo,ServerName> |
MetaTableAccessor.getRegion(Connection connection,
byte[] regionName)
Deprecated.
|
private static Optional<ServerName> |
AsyncMetaTableAccessor.getServerName(Result r,
int replicaId)
Returns a
ServerName from catalog table Result. |
Collection<ServerName> |
ClusterStatus.getServers()
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
Use
ClusterStatus.getLiveServerMetrics() instead. |
private static CompletableFuture<List<Pair<RegionInfo,ServerName>>> |
AsyncMetaTableAccessor.getTableRegionsAndLocations(AsyncTable<AdvancedScanResultConsumer> metaTable,
Optional<TableName> tableName,
boolean excludeOfflinedSplitParents)
Used to get table regions' info and server.
|
static List<Pair<RegionInfo,ServerName>> |
MetaTableAccessor.getTableRegionsAndLocations(Connection connection,
TableName tableName)
Do not use this method to get meta table regions, use methods in MetaTableLocator instead.
|
static List<Pair<RegionInfo,ServerName>> |
MetaTableAccessor.getTableRegionsAndLocations(Connection connection,
TableName tableName,
boolean excludeOfflinedSplitParents)
Do not use this method to get meta table regions, use methods in MetaTableLocator instead.
|
| Modifier and Type | Method and Description |
|---|---|
static Put |
MetaTableAccessor.addLocation(Put p,
ServerName sn,
long openSeqNum,
int replicaId) |
int |
ServerName.compareTo(ServerName other) |
ServerLoad |
ClusterStatus.getLoad(ServerName sn)
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
Use
ClusterStatus.getLiveServerMetrics() instead. |
static NavigableMap<RegionInfo,Result> |
MetaTableAccessor.getServerUserRegions(Connection connection,
ServerName serverName) |
boolean |
SplitLogTask.isDone(ServerName sn) |
boolean |
SplitLogTask.isErr(ServerName sn) |
boolean |
SplitLogTask.isOwned(ServerName sn) |
boolean |
SplitLogTask.isResigned(ServerName sn) |
static boolean |
ServerName.isSameAddress(ServerName left,
ServerName right) |
boolean |
SplitLogTask.isUnassigned(ServerName sn) |
static void |
MetaTableAccessor.mergeRegions(Connection connection,
RegionInfo mergedRegion,
RegionInfo[] parents,
ServerName sn,
int regionReplication)
Merge regions into one in an atomic operation.
|
static ServerMetricsBuilder |
ServerMetricsBuilder.newBuilder(ServerName sn) |
static ServerMetrics |
ServerMetricsBuilder.of(ServerName sn) |
static ServerMetrics |
ServerMetricsBuilder.of(ServerName sn,
int versionNumber) |
RegionLocations |
RegionLocations.removeByServer(ServerName serverName)
Returns a new RegionLocations with the locations removed (set to null)
which have the destination server as given.
|
ClusterMetricsBuilder |
ClusterMetricsBuilder.setMasterName(ServerName value) |
static void |
MetaTableAccessor.splitRegion(Connection connection,
RegionInfo parent,
RegionInfo splitA,
RegionInfo splitB,
ServerName sn,
int regionReplication)
Splits the region into two in an atomic operation.
|
static ServerMetrics |
ServerMetricsBuilder.toServerMetrics(ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.ServerLoad serverLoadPB) |
static ServerMetrics |
ServerMetricsBuilder.toServerMetrics(ServerName serverName,
int versionNumber,
org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.ServerLoad serverLoadPB) |
private static void |
MetaTableAccessor.updateLocation(Connection connection,
RegionInfo regionInfo,
ServerName sn,
long openSeqNum,
long masterSystemTime)
Updates the location of the specified region to be the specified server.
|
static void |
MetaTableAccessor.updateRegionLocation(Connection connection,
RegionInfo regionInfo,
ServerName sn,
long openSeqNum,
long masterSystemTime)
Updates the location of the specified region in hbase:meta to be the specified server hostname
and startcode.
|
| Modifier and Type | Method and Description |
|---|---|
private static List<RegionInfo> |
MetaTableAccessor.getListOfRegionInfos(List<Pair<RegionInfo,ServerName>> pairs) |
ClusterMetricsBuilder |
ClusterMetricsBuilder.setBackerMasterNames(List<ServerName> value) |
ClusterMetricsBuilder |
ClusterMetricsBuilder.setDeadServerNames(List<ServerName> value) |
ClusterMetricsBuilder |
ClusterMetricsBuilder.setLiveServerMetrics(Map<ServerName,ServerMetrics> value) |
| Constructor and Description |
|---|
ClusterMetricsImpl(String hbaseVersion,
List<ServerName> deadServerNames,
Map<ServerName,ServerMetrics> liveServerMetrics,
ServerName masterName,
List<ServerName> backupMasterNames,
List<RegionState> regionsInTransition,
String clusterId,
List<String> masterCoprocessorNames,
Boolean balancerOn,
int masterInfoPort) |
ClusterStatus(String hbaseVersion,
String clusterid,
Map<ServerName,ServerLoad> servers,
Collection<ServerName> deadServers,
ServerName master,
Collection<ServerName> backupMasters,
List<RegionState> rit,
String[] masterCoprocessors,
Boolean balancerOn,
int masterInfoPort)
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
|
Done(ServerName originServer) |
Err(ServerName originServer) |
HRegionLocation(RegionInfo regionInfo,
ServerName serverName) |
HRegionLocation(RegionInfo regionInfo,
ServerName serverName,
long seqNum) |
Owned(ServerName originServer) |
Resigned(ServerName originServer) |
ServerLoad(ServerName name,
org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.ServerLoad serverLoad)
Deprecated.
|
ServerMetricsBuilder(ServerName serverName) |
ServerMetricsImpl(ServerName serverName,
int versionNumber,
long requestCountPerSecond,
long requestCount,
Size usedHeapSize,
Size maxHeapSize,
int infoServerPort,
List<ReplicationLoadSource> sources,
ReplicationLoadSink sink,
Map<byte[],RegionMetrics> regionStatus,
Set<String> coprocessorNames,
long reportTimestamp,
long lastReportTimestamp) |
SplitLogTask(ServerName originServer,
org.apache.hadoop.hbase.shaded.protobuf.generated.ZooKeeperProtos.SplitLogTask.State state) |
Unassigned(ServerName originServer) |
| Constructor and Description |
|---|
ClusterMetricsImpl(String hbaseVersion,
List<ServerName> deadServerNames,
Map<ServerName,ServerMetrics> liveServerMetrics,
ServerName masterName,
List<ServerName> backupMasterNames,
List<RegionState> regionsInTransition,
String clusterId,
List<String> masterCoprocessorNames,
Boolean balancerOn,
int masterInfoPort) |
ClusterMetricsImpl(String hbaseVersion,
List<ServerName> deadServerNames,
Map<ServerName,ServerMetrics> liveServerMetrics,
ServerName masterName,
List<ServerName> backupMasterNames,
List<RegionState> regionsInTransition,
String clusterId,
List<String> masterCoprocessorNames,
Boolean balancerOn,
int masterInfoPort) |
ClusterMetricsImpl(String hbaseVersion,
List<ServerName> deadServerNames,
Map<ServerName,ServerMetrics> liveServerMetrics,
ServerName masterName,
List<ServerName> backupMasterNames,
List<RegionState> regionsInTransition,
String clusterId,
List<String> masterCoprocessorNames,
Boolean balancerOn,
int masterInfoPort) |
ClusterStatus(String hbaseVersion,
String clusterid,
Map<ServerName,ServerLoad> servers,
Collection<ServerName> deadServers,
ServerName master,
Collection<ServerName> backupMasters,
List<RegionState> rit,
String[] masterCoprocessors,
Boolean balancerOn,
int masterInfoPort)
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
|
ClusterStatus(String hbaseVersion,
String clusterid,
Map<ServerName,ServerLoad> servers,
Collection<ServerName> deadServers,
ServerName master,
Collection<ServerName> backupMasters,
List<RegionState> rit,
String[] masterCoprocessors,
Boolean balancerOn,
int masterInfoPort)
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
|
ClusterStatus(String hbaseVersion,
String clusterid,
Map<ServerName,ServerLoad> servers,
Collection<ServerName> deadServers,
ServerName master,
Collection<ServerName> backupMasters,
List<RegionState> rit,
String[] masterCoprocessors,
Boolean balancerOn,
int masterInfoPort)
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
|
| Modifier and Type | Field and Description |
|---|---|
private ServerName |
FastFailInterceptorContext.server |
private ServerName |
AsyncRequestFutureImpl.SingleServerRequestRunnable.server |
private ServerName |
ConnectionUtils.ShortCircuitingClusterConnection.serverName |
private ServerName |
AsyncServerRequestRpcRetryingCaller.serverName |
private ServerName |
AsyncAdminRequestRetryingCaller.serverName |
private ServerName |
AsyncRpcRetryingCallerFactory.AdminRequestCallerBuilder.serverName |
private ServerName |
AsyncRpcRetryingCallerFactory.ServerRequestCallerBuilder.serverName |
| Modifier and Type | Field and Description |
|---|---|
private Set<ServerName> |
MetaCache.cachedServers |
private List<ServerName> |
ClusterStatusListener.deadServers |
private ConcurrentMap<ServerName,ConnectionImplementation.ServerErrorTracker.ServerErrors> |
ConnectionImplementation.ServerErrorTracker.errorsByServer |
protected ConcurrentMap<ServerName,FailureInfo> |
PreemptiveFastFailInterceptor.repeatedFailuresMap |
private Map<ServerName,Long> |
SimpleRequestController.RequestHeapSizeChecker.serverRequestSizes |
private Map<ServerName,Long> |
SimpleRequestController.RequestRowsChecker.serverRows |
private Set<ServerName> |
SimpleRequestController.TaskCountChecker.serversIncluded |
protected ConcurrentHashMap<ServerName,ConcurrentMap<byte[],MetricsConnection.RegionStats>> |
MetricsConnection.serverStats |
private ConcurrentHashMap<ServerName,ServerStatistics> |
ServerStatisticTracker.stats |
(package private) ConcurrentMap<ServerName,AtomicInteger> |
SimpleRequestController.taskCounterPerServer |
private Map<ServerName,AtomicInteger> |
SimpleRequestController.TaskCountChecker.taskCounterPerServer |
| Modifier and Type | Method and Description |
|---|---|
default ServerName |
Admin.getMaster() |
ServerName |
FastFailInterceptorContext.getServer() |
(package private) ServerName |
MultiServerCallable.getServerName() |
| Modifier and Type | Method and Description |
|---|---|
void |
BatchErrors.add(Throwable ex,
Row row,
ServerName serverName) |
(package private) static void |
AsyncProcess.addAction(ServerName server,
byte[] regionName,
Action action,
Map<ServerName,MultiAction> actionsByServer,
long nonceGroup)
Helper that is used when grouping the actions per region server.
|
private void |
AsyncBatchRpcRetryingCaller.addError(Action action,
Throwable error,
ServerName serverName) |
private void |
AsyncBatchRpcRetryingCaller.addError(Iterable<Action> actions,
Throwable error,
ServerName serverName) |
void |
MetaCache.cacheLocation(TableName tableName,
ServerName source,
HRegionLocation location)
Put a newly discovered HRegionLocation into the cache.
|
private void |
ConnectionImplementation.cacheLocation(TableName tableName,
ServerName source,
HRegionLocation location)
Put a newly discovered HRegionLocation into the cache.
|
(package private) long |
ConnectionImplementation.ServerErrorTracker.calculateBackoffTime(ServerName server,
long basePause)
Calculates the back-off time for a retrying request to a particular server.
|
private void |
AsyncRequestFutureImpl.cleanServerCache(ServerName server,
Throwable regionException) |
private CompletableFuture<CacheEvictionStats> |
RawAsyncHBaseAdmin.clearBlockCache(ServerName serverName,
List<RegionInfo> hris) |
private CacheEvictionStats |
HBaseAdmin.clearBlockCache(ServerName sn,
List<RegionInfo> hris) |
void |
MetaCache.clearCache(ServerName serverName)
Delete all cached entries of a server.
|
void |
MetaCache.clearCache(TableName tableName,
byte[] row,
ServerName serverName)
Delete a cached location for a table, row and server
|
void |
ClusterConnection.clearCaches(ServerName sn)
Clear any caches that pertain to server name
sn. |
void |
ConnectionImplementation.clearCaches(ServerName serverName) |
void |
Admin.clearCompactionQueues(ServerName serverName,
Set<String> queues)
Clear compacting queues on a regionserver.
|
CompletableFuture<Void> |
AsyncAdmin.clearCompactionQueues(ServerName serverName,
Set<String> queues)
Clear compacting queues on a region server.
|
CompletableFuture<Void> |
RawAsyncHBaseAdmin.clearCompactionQueues(ServerName serverName,
Set<String> queues) |
CompletableFuture<Void> |
AsyncHBaseAdmin.clearCompactionQueues(ServerName serverName,
Set<String> queues) |
void |
HBaseAdmin.clearCompactionQueues(ServerName sn,
Set<String> queues) |
void |
Admin.closeRegion(ServerName sn,
HRegionInfo hri)
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
(HBASE-18231).
Use
Admin.unassign(byte[], boolean). |
void |
HBaseAdmin.closeRegion(ServerName unused,
HRegionInfo hri)
Deprecated.
|
private CompletableFuture<Void> |
RawAsyncHBaseAdmin.compact(ServerName sn,
RegionInfo hri,
boolean major,
byte[] columnFamily)
Compact the region at specific region server.
|
void |
Admin.compactRegionServer(ServerName serverName)
Compact all regions on the region server.
|
CompletableFuture<Void> |
AsyncAdmin.compactRegionServer(ServerName serverName)
Compact all regions on the region server.
|
CompletableFuture<Void> |
RawAsyncHBaseAdmin.compactRegionServer(ServerName sn) |
CompletableFuture<Void> |
AsyncHBaseAdmin.compactRegionServer(ServerName serverName) |
void |
HBaseAdmin.compactRegionServer(ServerName serverName) |
default void |
Admin.compactRegionServer(ServerName sn,
boolean major)
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0. Use
Admin.compactRegionServer(ServerName) or
Admin.majorCompactRegionServer(ServerName). |
private CompletableFuture<Void> |
RawAsyncHBaseAdmin.compactRegionServer(ServerName sn,
boolean major) |
<S,R> CompletableFuture<R> |
AsyncAdmin.coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
ServiceCaller<S,R> callable,
ServerName serverName)
Execute the given coprocessor call on the given region server.
|
<S,R> CompletableFuture<R> |
RawAsyncHBaseAdmin.coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
ServiceCaller<S,R> callable,
ServerName serverName) |
<S,R> CompletableFuture<R> |
AsyncHBaseAdmin.coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
ServiceCaller<S,R> callable,
ServerName serverName) |
CoprocessorRpcChannel |
Admin.coprocessorService(ServerName serverName)
Creates and returns a
RpcChannel instance
connected to the passed region server. |
CoprocessorRpcChannel |
HBaseAdmin.coprocessorService(ServerName serverName) |
private org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.Interface |
AsyncConnectionImpl.createAdminServerStub(ServerName serverName) |
private MultiServerCallable |
AsyncRequestFutureImpl.createCallable(ServerName server,
TableName tableName,
MultiAction multi)
Create a callable.
|
private String |
AsyncRequestFutureImpl.createLog(int numAttempt,
int failureCount,
int replaySize,
ServerName sn,
Throwable error,
long backOffTime,
boolean willRetry,
String startTime,
int failed,
int stopped) |
private org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MasterService.Interface |
AsyncConnectionImpl.createMasterStub(ServerName serverName) |
private org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface |
AsyncConnectionImpl.createRegionServerStub(ServerName serverName) |
static ClusterConnection |
ConnectionUtils.createShortCircuitConnection(org.apache.hadoop.conf.Configuration conf,
ExecutorService pool,
User user,
ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface admin,
org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.BlockingInterface client)
Creates a short-circuit connection that can bypass the RPC layer (serialization,
deserialization, networking, etc..) when talking to a local server.
|
(package private) AsyncRequestFutureImpl.SingleServerRequestRunnable |
AsyncRequestFutureImpl.createSingleServerRequest(MultiAction multiAction,
int numAttempt,
ServerName server,
Set<CancellableRegionServerCallable> callsInProgress) |
(package private) void |
AsyncProcess.decTaskCounters(Collection<byte[]> regions,
ServerName sn) |
void |
RequestController.decTaskCounters(Collection<byte[]> regions,
ServerName sn)
Decrement the counter if a task is accomplished.
|
void |
SimpleRequestController.decTaskCounters(Collection<byte[]> regions,
ServerName sn) |
private void |
AsyncBatchRpcRetryingCaller.failAll(Stream<Action> actions,
int tries,
Throwable error,
ServerName serverName) |
private CompletableFuture<Void> |
RawAsyncHBaseAdmin.flush(ServerName serverName,
RegionInfo regionInfo) |
void |
Admin.flushRegionServer(ServerName serverName)
Flush all regions on the region server.
|
CompletableFuture<Void> |
AsyncAdmin.flushRegionServer(ServerName serverName)
Flush all region on the region server.
|
CompletableFuture<Void> |
RawAsyncHBaseAdmin.flushRegionServer(ServerName sn) |
CompletableFuture<Void> |
AsyncHBaseAdmin.flushRegionServer(ServerName sn) |
void |
HBaseAdmin.flushRegionServer(ServerName serverName) |
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface |
ClusterConnection.getAdmin(ServerName serverName)
Establishes a connection to the region server at the specified address.
|
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface |
ConnectionUtils.ShortCircuitingClusterConnection.getAdmin(ServerName sn) |
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface |
ConnectionImplementation.getAdmin(ServerName serverName) |
(package private) org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.Interface |
AsyncConnectionImpl.getAdminStub(ServerName serverName) |
private Long |
AsyncRequestFutureImpl.getBackoff(ServerName server,
byte[] regionName) |
org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.BlockingInterface |
ClusterConnection.getClient(ServerName serverName)
Establishes a connection to the region server at the specified address, and returns
a region client protocol.
|
org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.BlockingInterface |
ConnectionUtils.ShortCircuitingClusterConnection.getClient(ServerName sn) |
org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.BlockingInterface |
ConnectionImplementation.getClient(ServerName serverName) |
private String |
AsyncBatchRpcRetryingCaller.getExtraContextForError(ServerName serverName) |
Hbck |
ClusterConnection.getHbck(ServerName masterServer)
Retrieve an Hbck implementation to fix an HBase cluster.
|
Hbck |
ConnectionImplementation.getHbck(ServerName masterServer) |
Hbck |
AsyncConnectionImpl.getHbck(ServerName masterServer) |
Hbck |
AsyncConnection.getHbck(ServerName masterServer)
Retrieve an Hbck implementation to fix an HBase cluster.
|
private Collection<? extends Runnable> |
AsyncRequestFutureImpl.getNewMultiActionRunnable(ServerName server,
MultiAction multiAction,
int numAttempt) |
List<HRegionInfo> |
Admin.getOnlineRegions(ServerName sn)
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
(HBASE-17980).
Use
Admin.getRegions(ServerName sn). |
List<HRegionInfo> |
HBaseAdmin.getOnlineRegions(ServerName sn)
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
Use
HBaseAdmin.getRegions(ServerName). |
private CompletableFuture<List<RegionMetrics>> |
RawAsyncHBaseAdmin.getRegionMetrics(org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionLoadRequest request,
ServerName serverName) |
default List<RegionMetrics> |
Admin.getRegionMetrics(ServerName serverName)
Get
RegionMetrics of all regions hosted on a regionserver. |
CompletableFuture<List<RegionMetrics>> |
AsyncAdmin.getRegionMetrics(ServerName serverName)
Get a list of
RegionMetrics of all regions hosted on a region seerver. |
CompletableFuture<List<RegionMetrics>> |
RawAsyncHBaseAdmin.getRegionMetrics(ServerName serverName) |
CompletableFuture<List<RegionMetrics>> |
AsyncHBaseAdmin.getRegionMetrics(ServerName serverName) |
List<RegionMetrics> |
Admin.getRegionMetrics(ServerName serverName,
TableName tableName)
Get
RegionMetrics of all regions hosted on a regionserver for a table. |
CompletableFuture<List<RegionMetrics>> |
AsyncAdmin.getRegionMetrics(ServerName serverName,
TableName tableName)
Get a list of
RegionMetrics of all regions hosted on a region seerver for a table. |
CompletableFuture<List<RegionMetrics>> |
RawAsyncHBaseAdmin.getRegionMetrics(ServerName serverName,
TableName tableName) |
CompletableFuture<List<RegionMetrics>> |
AsyncHBaseAdmin.getRegionMetrics(ServerName serverName,
TableName tableName) |
List<RegionMetrics> |
HBaseAdmin.getRegionMetrics(ServerName serverName,
TableName tableName) |
List<RegionInfo> |
Admin.getRegions(ServerName serverName)
Get all the online regions on a region server.
|
CompletableFuture<List<RegionInfo>> |
AsyncAdmin.getRegions(ServerName serverName)
Get all the online regions on a region server.
|
CompletableFuture<List<RegionInfo>> |
RawAsyncHBaseAdmin.getRegions(ServerName serverName) |
CompletableFuture<List<RegionInfo>> |
AsyncHBaseAdmin.getRegions(ServerName serverName) |
List<RegionInfo> |
HBaseAdmin.getRegions(ServerName sn) |
static org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.GetSpaceQuotaSnapshotsResponse |
QuotaStatusCalls.getRegionServerQuotaSnapshot(ClusterConnection clusterConn,
int timeout,
ServerName sn)
|
static org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.GetSpaceQuotaSnapshotsResponse |
QuotaStatusCalls.getRegionServerQuotaSnapshot(ClusterConnection conn,
RpcControllerFactory factory,
int timeout,
ServerName sn)
Executes an RPC to the RegionServer identified by the
ServerName to fetch its view
on space quotas. |
(package private) org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface |
AsyncConnectionImpl.getRegionServerStub(ServerName serverName) |
(package private) ServerStatistics |
ServerStatisticTracker.getServerStatsForTesting(ServerName server) |
ServerStatistics |
ServerStatisticTracker.getStats(ServerName server) |
(package private) static String |
ConnectionUtils.getStubKey(String serviceName,
ServerName serverName,
boolean hostnameCanChange)
Get a unique key for the rpc stub to the given server.
|
protected void |
PreemptiveFastFailInterceptor.handleFailureToServer(ServerName serverName,
Throwable t)
Handles failures encountered when communicating with a server.
|
void |
PreemptiveFastFailInterceptor.handleThrowable(Throwable t1,
ServerName serverName,
org.apache.commons.lang3.mutable.MutableBoolean couldNotCommunicateWithServer,
org.apache.commons.lang3.mutable.MutableBoolean guaranteedClientSideOnly) |
(package private) void |
AsyncProcess.incTaskCounters(Collection<byte[]> regions,
ServerName sn) |
void |
RequestController.incTaskCounters(Collection<byte[]> regions,
ServerName sn)
Increment the counter if we build a valid task.
|
void |
SimpleRequestController.incTaskCounters(Collection<byte[]> regions,
ServerName sn) |
private boolean |
PreemptiveFastFailInterceptor.inFastFailMode(ServerName server)
Checks to see if we are in the Fast fail mode for requests to the server.
|
boolean |
ClusterStatusListener.isDeadServer(ServerName sn)
Check if we know if a server is dead.
|
private boolean |
ConnectionImplementation.isDeadServer(ServerName sn) |
protected boolean |
PreemptiveFastFailInterceptor.isServerInFailureMap(ServerName serverName) |
private void |
AsyncBatchRpcRetryingCaller.logException(int tries,
Supplier<Stream<AsyncBatchRpcRetryingCaller.RegionRequest>> regionsSupplier,
Throwable error,
ServerName serverName) |
private void |
AsyncRequestFutureImpl.logNoResubmit(ServerName oldServer,
int numAttempt,
int failureCount,
Throwable throwable,
int failed,
int stopped) |
void |
Admin.majorCompactRegionServer(ServerName serverName)
Major compact all regions on the region server.
|
CompletableFuture<Void> |
AsyncAdmin.majorCompactRegionServer(ServerName serverName)
Compact all regions on the region server.
|
CompletableFuture<Void> |
RawAsyncHBaseAdmin.majorCompactRegionServer(ServerName sn) |
CompletableFuture<Void> |
AsyncHBaseAdmin.majorCompactRegionServer(ServerName serverName) |
void |
HBaseAdmin.majorCompactRegionServer(ServerName serverName) |
(package private) AsyncRequestFutureImpl.Retry |
AsyncRequestFutureImpl.manageError(int originalIndex,
Row row,
AsyncRequestFutureImpl.Retry canRetry,
Throwable throwable,
ServerName server)
Check that we can retry acts accordingly: logs, set the error status.
|
CompletableFuture<Void> |
AsyncAdmin.move(byte[] regionName,
ServerName destServerName)
Move the region
r to dest. |
CompletableFuture<Void> |
RawAsyncHBaseAdmin.move(byte[] regionName,
ServerName destServerName) |
CompletableFuture<Void> |
AsyncHBaseAdmin.move(byte[] regionName,
ServerName destServerName) |
void |
ClusterStatusListener.DeadServerHandler.newDead(ServerName sn)
Called when a server is identified as dead.
|
private void |
AsyncBatchRpcRetryingCaller.onComplete(Action action,
AsyncBatchRpcRetryingCaller.RegionRequest regionReq,
int tries,
ServerName serverName,
MultiResponse.RegionResult regionResult,
List<Action> failedActions,
Throwable regionException) |
private void |
AsyncBatchRpcRetryingCaller.onComplete(Map<byte[],AsyncBatchRpcRetryingCaller.RegionRequest> actionsByRegion,
int tries,
ServerName serverName,
MultiResponse resp) |
private void |
AsyncBatchRpcRetryingCaller.onError(Map<byte[],AsyncBatchRpcRetryingCaller.RegionRequest> actionsByRegion,
int tries,
Throwable t,
ServerName serverName) |
private void |
AsyncRequestFutureImpl.receiveGlobalFailure(MultiAction rsActions,
ServerName server,
int numAttempt,
Throwable t)
Resubmit all the actions from this multiaction after a failure.
|
private void |
AsyncRequestFutureImpl.receiveMultiAction(MultiAction multiAction,
ServerName server,
MultiResponse responses,
int numAttempt)
Called when we receive the result of a server query.
|
void |
Admin.recommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames)
Remove decommission marker from a region server to allow regions assignments.
|
CompletableFuture<Void> |
AsyncAdmin.recommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames)
Remove decommission marker from a region server to allow regions assignments.
|
CompletableFuture<Void> |
RawAsyncHBaseAdmin.recommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames) |
CompletableFuture<Void> |
AsyncHBaseAdmin.recommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames) |
void |
HBaseAdmin.recommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames) |
(package private) void |
ConnectionImplementation.ServerErrorTracker.reportServerError(ServerName server)
Reports that there was an error on the server to do whatever bean-counting necessary.
|
void |
MultiServerCallable.reset(ServerName location,
MultiAction multiAction) |
private void |
AsyncRequestFutureImpl.resubmit(ServerName oldServer,
List<Action> toReplay,
int numAttempt,
int failureCount,
Throwable throwable)
Log as much info as possible, and, if there is something to replay,
submit it again after a back off sleep.
|
void |
Admin.rollWALWriter(ServerName serverName)
Roll the log writer.
|
CompletableFuture<Void> |
AsyncAdmin.rollWALWriter(ServerName serverName)
Roll the log writer.
|
CompletableFuture<Void> |
RawAsyncHBaseAdmin.rollWALWriter(ServerName serverName) |
CompletableFuture<Void> |
AsyncHBaseAdmin.rollWALWriter(ServerName serverName) |
void |
HBaseAdmin.rollWALWriter(ServerName serverName) |
private org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.RollWALWriterResponse |
HBaseAdmin.rollWALWriterImpl(ServerName sn) |
AsyncRpcRetryingCallerFactory.AdminRequestCallerBuilder<T> |
AsyncRpcRetryingCallerFactory.AdminRequestCallerBuilder.serverName(ServerName serverName) |
AsyncRpcRetryingCallerFactory.ServerRequestCallerBuilder<T> |
AsyncRpcRetryingCallerFactory.ServerRequestCallerBuilder.serverName(ServerName serverName) |
private void |
AsyncRequestFutureImpl.setError(int index,
Row row,
Throwable throwable,
ServerName server)
Sets the error from a particular action.
|
void |
FastFailInterceptorContext.setServer(ServerName server) |
protected abstract void |
RegionServerCallable.setStubByServiceName(ServerName serviceName)
Set the RCP client stub
|
protected void |
ClientServiceCallable.setStubByServiceName(ServerName serviceName) |
protected void |
CancellableRegionServerCallable.setStubByServiceName(ServerName serviceName) |
CompletableFuture<Void> |
AsyncAdmin.stopRegionServer(ServerName serverName)
Stop the designated regionserver.
|
CompletableFuture<Void> |
RawAsyncHBaseAdmin.stopRegionServer(ServerName serverName) |
CompletableFuture<Void> |
AsyncHBaseAdmin.stopRegionServer(ServerName serverName) |
private AsyncRequestFutureImpl.ReplicaResultState |
AsyncRequestFutureImpl.trySetResultSimple(int index,
Row row,
boolean isError,
Object result,
ServerName server,
boolean isFromReplica)
Tries to set the result or error for a particular action as if there were no replica calls.
|
(package private) void |
ConnectionImplementation.updateCachedLocation(RegionInfo hri,
ServerName source,
ServerName serverName,
long seqNum) |
private void |
AsyncRequestFutureImpl.updateCachedLocations(ServerName server,
byte[] regionName,
byte[] row,
Throwable rowException) |
void |
ClusterConnection.updateCachedLocations(TableName tableName,
byte[] regionName,
byte[] rowkey,
Object exception,
ServerName source)
Update the location cache.
|
void |
ConnectionImplementation.updateCachedLocations(TableName tableName,
byte[] regionName,
byte[] rowkey,
Object exception,
ServerName source)
Update the location with the new value (if the exception is a RegionMovedException)
or delete it from the cache.
|
void |
Admin.updateConfiguration(ServerName server)
Update the configuration and trigger an online config change
on the regionserver.
|
CompletableFuture<Void> |
AsyncAdmin.updateConfiguration(ServerName serverName)
Update the configuration and trigger an online config change on the regionserver.
|
CompletableFuture<Void> |
RawAsyncHBaseAdmin.updateConfiguration(ServerName serverName) |
CompletableFuture<Void> |
AsyncHBaseAdmin.updateConfiguration(ServerName serverName) |
void |
HBaseAdmin.updateConfiguration(ServerName server) |
private void |
PreemptiveFastFailInterceptor.updateFailureInfoForServer(ServerName server,
FailureInfo fInfo,
boolean didTry,
boolean couldNotCommunicate,
boolean retryDespiteFastFailMode)
This function updates the Failure info for a particular server after the
attempt to
|
void |
StatisticTrackable.updateRegionStats(ServerName server,
byte[] region,
RegionLoadStats stats)
Update stats per region.
|
void |
ServerStatisticTracker.updateRegionStats(ServerName server,
byte[] region,
RegionLoadStats currentStats) |
void |
MetricsConnection.updateRegionStats(ServerName serverName,
byte[] regionName,
RegionLoadStats stats) |
void |
MetricsConnection.updateServerStats(ServerName serverName,
byte[] regionName,
Object r) |
protected void |
AsyncRequestFutureImpl.updateStats(ServerName server,
Map<byte[],MultiResponse.RegionResult> results) |
static void |
ResultStatsUtil.updateStats(StatisticTrackable tracker,
ServerName server,
byte[] regionName,
RegionLoadStats stats) |
static <T> T |
ResultStatsUtil.updateStats(T r,
ServerStatisticTracker serverStats,
ServerName server,
byte[] regionName)
Update the stats for the specified region if the result is an instance of
ResultStatsUtil |
| Modifier and Type | Method and Description |
|---|---|
(package private) static void |
AsyncProcess.addAction(ServerName server,
byte[] regionName,
Action action,
Map<ServerName,MultiAction> actionsByServer,
long nonceGroup)
Helper that is used when grouping the actions per region server.
|
private void |
AsyncRequestFutureImpl.ReplicaCallIssuingRunnable.addReplicaActions(int index,
Map<ServerName,MultiAction> actionsByServer,
List<Action> unknownReplicaActions)
Add replica actions to action map by server.
|
private void |
AsyncRequestFutureImpl.ReplicaCallIssuingRunnable.addReplicaActionsAgain(Action action,
Map<ServerName,MultiAction> actionsByServer) |
List<ServerName> |
Admin.clearDeadServers(List<ServerName> servers)
Clear dead region servers from master.
|
CompletableFuture<List<ServerName>> |
AsyncAdmin.clearDeadServers(List<ServerName> servers)
Clear dead region servers from master.
|
CompletableFuture<List<ServerName>> |
RawAsyncHBaseAdmin.clearDeadServers(List<ServerName> servers) |
CompletableFuture<List<ServerName>> |
AsyncHBaseAdmin.clearDeadServers(List<ServerName> servers) |
List<ServerName> |
HBaseAdmin.clearDeadServers(List<ServerName> servers) |
void |
Admin.decommissionRegionServers(List<ServerName> servers,
boolean offload)
Mark region server(s) as decommissioned to prevent additional regions from getting
assigned to them.
|
CompletableFuture<Void> |
AsyncAdmin.decommissionRegionServers(List<ServerName> servers,
boolean offload)
Mark region server(s) as decommissioned to prevent additional regions from getting
assigned to them.
|
CompletableFuture<Void> |
RawAsyncHBaseAdmin.decommissionRegionServers(List<ServerName> servers,
boolean offload) |
CompletableFuture<Void> |
AsyncHBaseAdmin.decommissionRegionServers(List<ServerName> servers,
boolean offload) |
void |
HBaseAdmin.decommissionRegionServers(List<ServerName> servers,
boolean offload) |
private void |
AsyncBatchRpcRetryingCaller.send(Map<ServerName,AsyncBatchRpcRetryingCaller.ServerRequest> actionsByServer,
int tries) |
(package private) void |
AsyncRequestFutureImpl.sendMultiAction(Map<ServerName,MultiAction> actionsByServer,
int numAttempt,
List<Action> actionsForReplicaThread,
boolean reuseThread)
Send a multi action structure to the servers, after a delay depending on the attempt
number.
|
(package private) <CResult> AsyncRequestFuture |
AsyncProcess.submitMultiActions(AsyncProcessTask task,
List<Action> retainedActions,
long nonceGroup,
List<Exception> locationErrors,
List<Integer> locationErrorRows,
Map<ServerName,MultiAction> actionsByServer) |
| Constructor and Description |
|---|
AsyncAdminRequestRetryingCaller(org.apache.hbase.thirdparty.io.netty.util.Timer retryTimer,
AsyncConnectionImpl conn,
long pauseNs,
int maxAttempts,
long operationTimeoutNs,
long rpcTimeoutNs,
int startLogErrorsCnt,
ServerName serverName,
AsyncAdminRequestRetryingCaller.Callable<T> callable) |
AsyncServerRequestRpcRetryingCaller(org.apache.hbase.thirdparty.io.netty.util.Timer retryTimer,
AsyncConnectionImpl conn,
long pauseNs,
int maxAttempts,
long operationTimeoutNs,
long rpcTimeoutNs,
int startLogErrorsCnt,
ServerName serverName,
AsyncServerRequestRpcRetryingCaller.Callable<T> callable) |
MultiServerCallable(ClusterConnection connection,
TableName tableName,
ServerName location,
MultiAction multi,
org.apache.hbase.thirdparty.com.google.protobuf.RpcController rpcController,
int rpcTimeout,
RetryingTimeTracker tracker,
int priority) |
ShortCircuitingClusterConnection(org.apache.hadoop.conf.Configuration conf,
ExecutorService pool,
User user,
ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface admin,
org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.BlockingInterface client) |
SingleServerRequestRunnable(MultiAction multiAction,
int numAttempt,
ServerName server,
Set<CancellableRegionServerCallable> callsInProgress) |
| Constructor and Description |
|---|
TaskCountChecker(int maxTotalConcurrentTasks,
int maxConcurrentTasksPerServer,
int maxConcurrentTasksPerRegion,
AtomicLong tasksInProgress,
Map<ServerName,AtomicInteger> taskCounterPerServer,
Map<byte[],AtomicInteger> taskCounterPerRegion) |
| Modifier and Type | Method and Description |
|---|---|
long |
ClientBackoffPolicyFactory.NoBackoffPolicy.getBackoffTime(ServerName serverName,
byte[] region,
ServerStatistics stats) |
long |
ClientBackoffPolicy.getBackoffTime(ServerName serverName,
byte[] region,
ServerStatistics stats) |
long |
ExponentialClientBackoffPolicy.getBackoffTime(ServerName serverName,
byte[] region,
ServerStatistics stats) |
| Modifier and Type | Field and Description |
|---|---|
private ServerName |
ZkSplitLogWorkerCoordination.serverName |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
SplitLogManagerCoordination.SplitLogManagerDetails.getServerName() |
| Modifier and Type | Method and Description |
|---|---|
protected static int |
ZkSplitLogWorkerCoordination.attemptToOwnTask(boolean isFirstTime,
ZKWatcher zkw,
ServerName server,
String task,
int taskZKVersion)
Try to own the task by transitioning the zk node data from UNASSIGNED to OWNED.
|
ZKSplitLogManagerCoordination.TaskFinisher.Status |
ZKSplitLogManagerCoordination.TaskFinisher.finish(ServerName workerName,
String taskname)
finish the partially done task.
|
private void |
ZKSplitLogManagerCoordination.heartbeat(String path,
int new_version,
ServerName workerName) |
| Constructor and Description |
|---|
ZkSplitLogWorkerCoordination(ServerName serverName,
ZKWatcher watcher) |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
MasterCoprocessorEnvironment.getServerName() |
ServerName |
RegionCoprocessorEnvironment.getServerName() |
ServerName |
RegionServerCoprocessorEnvironment.getServerName() |
| Modifier and Type | Method and Description |
|---|---|
default void |
MasterObserver.postMove(ObserverContext<MasterCoprocessorEnvironment> ctx,
RegionInfo region,
ServerName srcServer,
ServerName destServer)
Called after the region move has been requested.
|
default void |
MasterObserver.postRecommissionRegionServer(ObserverContext<MasterCoprocessorEnvironment> ctx,
ServerName server,
List<byte[]> encodedRegionNames)
Called after recommission region server.
|
default void |
MasterObserver.preMove(ObserverContext<MasterCoprocessorEnvironment> ctx,
RegionInfo region,
ServerName srcServer,
ServerName destServer)
Called prior to moving a given region from one region server to another.
|
default void |
MasterObserver.preRecommissionRegionServer(ObserverContext<MasterCoprocessorEnvironment> ctx,
ServerName server,
List<byte[]> encodedRegionNames)
Called before recommission region server.
|
| Modifier and Type | Method and Description |
|---|---|
default void |
MasterObserver.postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ServerName> servers,
List<ServerName> notClearedServers)
Called after clear dead region servers.
|
default void |
MasterObserver.postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ServerName> servers,
List<ServerName> notClearedServers)
Called after clear dead region servers.
|
default void |
MasterObserver.postDecommissionRegionServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ServerName> servers,
boolean offload)
Called after decommission region servers.
|
default void |
MasterObserver.preDecommissionRegionServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ServerName> servers,
boolean offload)
Called before decommission region servers.
|
| Modifier and Type | Method and Description |
|---|---|
ServerName |
RegionMovedException.getServerName() |
| Constructor and Description |
|---|
PreemptiveFastFailException(long count,
long timeOfFirstFailureMilliSec,
long timeOfLatestAttemptMilliSec,
ServerName serverName) |
PreemptiveFastFailException(long count,
long timeOfFirstFailureMilliSec,
long timeOfLatestAttemptMilliSec,
ServerName serverName,
boolean guaranteedClientSideOnly) |
RegionMovedException(ServerName serverName,
long locationSeqNum) |
| Modifier and Type | Class and Description |
|---|---|
(package private) class |
StartcodeAgnosticServerName
This class differs from ServerName in that start code is always ignored.
|
| Modifier and Type | Field and Description |
|---|---|
private Map<String,List<ServerName>> |
FavoredNodesPlan.favoredNodesMap
the map between each region name and its favored region server list
|
private Map<ServerName,List<RegionInfo>> |
FavoredNodesManager.primaryRSToRegionMap |
private Map<String,List<ServerName>> |
FavoredNodeAssignmentHelper.rackToRegionServerMap |
private Map<ServerName,List<RegionInfo>> |
FavoredNodesManager.secondaryRSToRegionMap |
private List<ServerName> |
FavoredNodeAssignmentHelper.servers |
private Map<ServerName,List<RegionInfo>> |
FavoredNodesManager.teritiaryRSToRegionMap |
| Modifier and Type | Method and Description |
|---|---|
private ServerName |
FavoredNodeLoadBalancer.availableServersContains(List<ServerName> servers,
ServerName favoredNode) |
ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNode(List<ServerName> favoredNodes) |
ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNode(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
private ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNodeMultiRack(List<ServerName> favoredNodes) |
private ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNodeMultiRack(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
private ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNodeSingleRack(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
static ServerName[] |
FavoredNodeAssignmentHelper.getFavoredNodesList(byte[] favoredNodes) |
private ServerName |
FavoredNodeAssignmentHelper.getOneRandomServer(String rack) |
protected ServerName |
FavoredNodeAssignmentHelper.getOneRandomServer(String rack,
Set<ServerName> skipServerSet)
Gets a random server from the specified rack and skips anything specified.
|
ServerName[] |
FavoredNodeAssignmentHelper.getSecondaryAndTertiary(RegionInfo regionInfo,
ServerName primaryRS) |
private ServerName[] |
FavoredNodeAssignmentHelper.multiRackCase(RegionInfo regionInfo,
ServerName primaryRS,
String primaryRack)
Place secondary and tertiary nodes in a multi rack case.
|
private ServerName[] |
FavoredNodeAssignmentHelper.multiRackCaseWithRestrictions(Map<ServerName,Set<RegionInfo>> serverToPrimaries,
Map<RegionInfo,ServerName[]> secondaryAndTertiaryMap,
String primaryRack,
ServerName primaryRS,
RegionInfo regionInfo) |
ServerName |
FavoredNodeLoadBalancer.randomAssignment(RegionInfo regionInfo,
List<ServerName> servers) |
private ServerName[] |
FavoredNodeAssignmentHelper.singleRackCase(RegionInfo regionInfo,
ServerName primaryRS,
String primaryRack) |
| Modifier and Type | Method and Description |
|---|---|
private void |
FavoredNodeLoadBalancer.addRegionToMap(Map<ServerName,List<RegionInfo>> assignmentMapForFavoredNodes,
RegionInfo region,
ServerName host) |
private void |
FavoredNodeLoadBalancer.assignRegionToAvailableFavoredNode(Map<ServerName,List<RegionInfo>> assignmentMapForFavoredNodes,
RegionInfo region,
ServerName primaryHost,
ServerName secondaryHost,
ServerName tertiaryHost) |
private ServerName |
FavoredNodeLoadBalancer.availableServersContains(List<ServerName> servers,
ServerName favoredNode) |
int |
StartcodeAgnosticServerName.compareTo(ServerName other) |
static FavoredNodesPlan.Position |
FavoredNodesPlan.getFavoredServerPosition(List<ServerName> favoredNodes,
ServerName server)
Return the position of the server in the favoredNodes list.
|
private String |
FavoredNodeAssignmentHelper.getRackOfServer(ServerName sn) |
Set<RegionInfo> |
FavoredNodesManager.getRegionsOfFavoredNode(ServerName serverName) |
ServerName[] |
FavoredNodeAssignmentHelper.getSecondaryAndTertiary(RegionInfo regionInfo,
ServerName primaryRS) |
private ServerName[] |
FavoredNodeAssignmentHelper.multiRackCase(RegionInfo regionInfo,
ServerName primaryRS,
String primaryRack)
Place secondary and tertiary nodes in a multi rack case.
|
private ServerName[] |
FavoredNodeAssignmentHelper.multiRackCaseWithRestrictions(Map<ServerName,Set<RegionInfo>> serverToPrimaries,
Map<RegionInfo,ServerName[]> secondaryAndTertiaryMap,
String primaryRack,
ServerName primaryRS,
RegionInfo regionInfo) |
private ServerName[] |
FavoredNodeAssignmentHelper.singleRackCase(RegionInfo regionInfo,
ServerName primaryRS,
String primaryRack) |
static StartcodeAgnosticServerName |
StartcodeAgnosticServerName.valueOf(ServerName serverName) |
| Modifier and Type | Method and Description |
|---|---|
private void |
FavoredNodeLoadBalancer.addRegionToMap(Map<ServerName,List<RegionInfo>> assignmentMapForFavoredNodes,
RegionInfo region,
ServerName host) |
private void |
FavoredNodesManager.addToReplicaLoad(RegionInfo hri,
List<ServerName> servers) |
private void |
FavoredNodeLoadBalancer.assignRegionToAvailableFavoredNode(Map<ServerName,List<RegionInfo>> assignmentMapForFavoredNodes,
RegionInfo region,
ServerName primaryHost,
ServerName secondaryHost,
ServerName tertiaryHost) |
private void |
FavoredNodeLoadBalancer.assignSecondaryAndTertiaryNodesForRegion(FavoredNodeAssignmentHelper assignmentHelper,
List<RegionInfo> regions,
Map<RegionInfo,ServerName> primaryRSMap) |
private ServerName |
FavoredNodeLoadBalancer.availableServersContains(List<ServerName> servers,
ServerName favoredNode) |
List<RegionPlan> |
FavoredNodeLoadBalancer.balanceCluster(Map<ServerName,List<RegionInfo>> clusterState) |
List<RegionPlan> |
FavoredNodeLoadBalancer.balanceCluster(TableName tableName,
Map<ServerName,List<RegionInfo>> clusterState) |
private Map<RegionInfo,List<ServerName>> |
FavoredNodeAssignmentHelper.generateFavoredNodes(Map<RegionInfo,ServerName> primaryRSMap) |
void |
FavoredNodeLoadBalancer.generateFavoredNodesForDaughter(List<ServerName> servers,
RegionInfo parent,
RegionInfo regionA,
RegionInfo regionB) |
void |
FavoredNodesPromoter.generateFavoredNodesForDaughter(List<ServerName> servers,
RegionInfo parent,
RegionInfo hriA,
RegionInfo hriB) |
Map<RegionInfo,List<ServerName>> |
FavoredNodeAssignmentHelper.generateFavoredNodesRoundRobin(Map<ServerName,List<RegionInfo>> assignmentMap,
List<RegionInfo> regions) |
ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNode(List<ServerName> favoredNodes) |
ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNode(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNode(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
private ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNodeMultiRack(List<ServerName> favoredNodes) |
private ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNodeMultiRack(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
private ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNodeMultiRack(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
private ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNodeSingleRack(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
private ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNodeSingleRack(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
static byte[] |
FavoredNodeAssignmentHelper.getFavoredNodes(List<ServerName> serverAddrList) |
static String |
FavoredNodeAssignmentHelper.getFavoredNodesAsString(List<ServerName> nodes) |
static FavoredNodesPlan.Position |
FavoredNodesPlan.getFavoredServerPosition(List<ServerName> favoredNodes,
ServerName server)
Return the position of the server in the favoredNodes list.
|
private Set<ServerName> |
FavoredNodeLoadBalancer.getInheritedFNForDaughter(FavoredNodeAssignmentHelper helper,
List<ServerName> parentFavoredNodes,
FavoredNodesPlan.Position primary,
FavoredNodesPlan.Position secondary) |
protected ServerName |
FavoredNodeAssignmentHelper.getOneRandomServer(String rack,
Set<ServerName> skipServerSet)
Gets a random server from the specified rack and skips anything specified.
|
Map<ServerName,List<Integer>> |
FavoredNodesManager.getReplicaLoad(List<ServerName> servers) |
private static Put |
FavoredNodeAssignmentHelper.makePutFromRegionInfo(RegionInfo regionInfo,
List<ServerName> favoredNodeList)
Generates and returns a Put containing the region info for the catalog table and the servers
|
private Map<ServerName,Set<RegionInfo>> |
FavoredNodeAssignmentHelper.mapRSToPrimaries(Map<RegionInfo,ServerName> primaryRSMap) |
private ServerName[] |
FavoredNodeAssignmentHelper.multiRackCaseWithRestrictions(Map<ServerName,Set<RegionInfo>> serverToPrimaries,
Map<RegionInfo,ServerName[]> secondaryAndTertiaryMap,
String primaryRack,
ServerName primaryRS,
RegionInfo regionInfo) |
void |
FavoredNodeAssignmentHelper.placePrimaryRSAsRoundRobin(Map<ServerName,List<RegionInfo>> assignmentMap,
Map<RegionInfo,ServerName> primaryRSMap,
List<RegionInfo> regions) |
void |
FavoredNodeAssignmentHelper.placePrimaryRSAsRoundRobin(Map<ServerName,List<RegionInfo>> assignmentMap,
Map<RegionInfo,ServerName> primaryRSMap,
List<RegionInfo> regions) |
Map<RegionInfo,ServerName[]> |
FavoredNodeAssignmentHelper.placeSecondaryAndTertiaryRS(Map<RegionInfo,ServerName> primaryRSMap) |
Map<RegionInfo,ServerName[]> |
FavoredNodeAssignmentHelper.placeSecondaryAndTertiaryWithRestrictions(Map<RegionInfo,ServerName> primaryRSMap)
For regions that share the primary, avoid placing the secondary and tertiary
on a same RS.
|
ServerName |
FavoredNodeLoadBalancer.randomAssignment(RegionInfo regionInfo,
List<ServerName> servers) |
Map<ServerName,List<RegionInfo>> |
FavoredNodeLoadBalancer.roundRobinAssignment(List<RegionInfo> regions,
List<ServerName> servers) |
private void |
FavoredNodeLoadBalancer.roundRobinAssignmentImpl(FavoredNodeAssignmentHelper assignmentHelper,
Map<ServerName,List<RegionInfo>> assignmentMap,
List<RegionInfo> regions,
List<ServerName> servers) |
private void |
FavoredNodeLoadBalancer.roundRobinAssignmentImpl(FavoredNodeAssignmentHelper assignmentHelper,
Map<ServerName,List<RegionInfo>> assignmentMap,
List<RegionInfo> regions,
List<ServerName> servers) |
private Pair<Map<ServerName,List<RegionInfo>>,List<RegionInfo>> |
FavoredNodeLoadBalancer.segregateRegionsAndAssignRegionsWithFavoredNodes(List<RegionInfo> regions,
List<ServerName> availableServers) |
void |
FavoredNodesManager.updateFavoredNodes(Map<RegionInfo,List<ServerName>> regionFNMap) |
void |
FavoredNodesPlan.updateFavoredNodesMap(RegionInfo region,
List<ServerName> servers)
Update an assignment to the plan
|
static void |
FavoredNodeAssignmentHelper.updateMetaWithFavoredNodesInfo(Map<RegionInfo,List<ServerName>> regionToFavoredNodes,
org.apache.hadoop.conf.Configuration conf)
Update meta table with favored nodes info
|
static void |
FavoredNodeAssignmentHelper.updateMetaWithFavoredNodesInfo(Map<RegionInfo,List<ServerName>> regionToFavoredNodes,
Connection connection)
Update meta table with favored nodes info
|
| Constructor and Description |
|---|
FavoredNodeAssignmentHelper(List<ServerName> servers,
org.apache.hadoop.conf.Configuration conf) |
FavoredNodeAssignmentHelper(List<ServerName> servers,
RackManager rackManager) |
| Modifier and Type | Method and Description |
|---|---|
void |
RpcClient.cancelConnections(ServerName sn)
Interrupt the connections to the given server.
|
void |
AbstractRpcClient.cancelConnections(ServerName sn)
Interrupt the connections to the given ip:port server.
|
private InetSocketAddress |
AbstractRpcClient.createAddr(ServerName sn) |
org.apache.hbase.thirdparty.com.google.protobuf.BlockingRpcChannel |
RpcClient.createBlockingRpcChannel(ServerName sn,
User user,
int rpcTimeout)
Creates a "channel" that can be used by a blocking protobuf service.
|
org.apache.hbase.thirdparty.com.google.protobuf.BlockingRpcChannel |
AbstractRpcClient.createBlockingRpcChannel(ServerName sn,
User ticket,
int rpcTimeout) |
org.apache.hbase.thirdparty.com.google.protobuf.RpcChannel |
RpcClient.createRpcChannel(ServerName sn,
User user,
int rpcTimeout)
Creates a "channel" that can be used by a protobuf service.
|
org.apache.hbase.thirdparty.com.google.protobuf.RpcChannel |
AbstractRpcClient.createRpcChannel(ServerName sn,
User user,
int rpcTimeout) |
| Modifier and Type | Method and Description |
|---|---|
private Set<ServerName> |
RegionSizeCalculator.getRegionServersOfTable(RegionLocator regionLocator) |
| Modifier and Type | Field and Description |
|---|---|
static ServerName |
LoadBalancer.BOGUS_SERVER_NAME |
ServerName |
SplitLogManager.Task.cur_worker_name |
private ServerName |
RegionPlan.dest |
private ServerName |
RegionState.serverName |
private ServerName |
ActiveMasterManager.sn |
private ServerName |
RegionPlan.source |
| Modifier and Type | Field and Description |
|---|---|
private Map<ServerName,List<RegionInfo>> |
SnapshotOfRegionAssignmentFromMeta.currentRSToRegionMap
the regionServer to region map
|
private Map<ServerName,Long> |
DeadServer.deadServers
Set of known dead servers.
|
private Set<ServerName> |
SplitLogManager.deadWorkers |
private ArrayList<ServerName> |
ServerManager.drainingServers
List of region servers that should not get any more new regions.
|
private NavigableSet<ServerName> |
DrainingServerTracker.drainingServers |
private Map<String,Pair<ServerName,List<ServerName>>> |
HbckChore.inconsistentRegions
The inconsistent regions.
|
private Map<String,Pair<ServerName,List<ServerName>>> |
HbckChore.inconsistentRegions
The inconsistent regions.
|
private Map<String,Pair<ServerName,List<ServerName>>> |
HbckChore.inconsistentRegionsSnapshot |
private Map<String,Pair<ServerName,List<ServerName>>> |
HbckChore.inconsistentRegionsSnapshot |
private ConcurrentMap<ServerName,Integer> |
ClusterStatusPublisher.lastSent |
private Set<ServerName> |
AssignmentVerificationReport.leastLoadedRSSet |
private Set<ServerName> |
AssignmentVerificationReport.maxDispersionNumServerSet |
private Set<ServerName> |
AssignmentVerificationReport.maxDispersionScoreServerSet |
private Set<ServerName> |
AssignmentVerificationReport.minDispersionNumServerSet |
private Set<ServerName> |
AssignmentVerificationReport.minDispersionScoreServerSet |
private Set<ServerName> |
AssignmentVerificationReport.mostLoadedRSSet |
private ConcurrentNavigableMap<ServerName,ServerMetrics> |
ServerManager.onlineServers
Map of registered servers to their current load
|
private Map<String,ServerName> |
HbckChore.orphanRegionsOnRS
The regions only opened on RegionServers, but no region info in meta.
|
private Map<String,ServerName> |
HbckChore.orphanRegionsOnRSSnapshot
The "snapshot" is used to save the last round's HBCK checking report.
|
private Map<ServerName,List<RegionInfo>> |
SnapshotOfRegionAssignmentFromMeta.primaryRSToRegionMap |
private Set<ServerName> |
DeadServer.processingServers
Set of dead servers currently being processed
|
private Set<ServerName> |
RegionServerTracker.regionServers |
private Map<RegionInfo,ServerName> |
SnapshotOfRegionAssignmentFromMeta.regionToRegionServerMap
the region to region server map
|
private Map<ServerName,org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface> |
ServerManager.rsAdmins
Map of admin interfaces per registered regionserver; these interfaces we use to control
regionservers out on the cluster
|
private Map<ServerName,List<RegionInfo>> |
SnapshotOfRegionAssignmentFromMeta.secondaryRSToRegionMap |
private static Comparator<Pair<ServerName,Long>> |
DeadServer.ServerNameDeathDateComparator |
private Map<ServerName,List<RegionInfo>> |
SnapshotOfRegionAssignmentFromMeta.teritiaryRSToRegionMap |
private List<Pair<RegionInfo,ServerName>> |
CatalogJanitor.Report.unknownServers |
| Modifier and Type | Method and Description |
|---|---|
private ServerName |
ServerManager.findServerWithSameHostnamePortWithLock(ServerName serverName)
Assumes onlineServers is locked.
|
ServerName |
RegionPlan.getDestination()
Get the destination server for the plan for this region.
|
private ServerName |
MasterStatusServlet.getMetaLocationOrNull(HMaster master) |
ServerName |
RegionState.getServerName() |
ServerName |
MasterCoprocessorHost.MasterEnvironment.getServerName() |
ServerName |
HMaster.getServerName() |
ServerName |
RegionPlan.getSource()
Get the source server for the plan for this region.
|
ServerName |
LoadBalancer.randomAssignment(RegionInfo regionInfo,
List<ServerName> servers)
Get a random region server from the list
|
(package private) ServerName |
ServerManager.regionServerStartup(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStartupRequest request,
int versionNumber,
InetAddress ia)
Let the server manager know a new regionserver has come online
|
| Modifier and Type | Method and Description |
|---|---|
List<Pair<ServerName,Long>> |
DeadServer.copyDeadServersSince(long ts)
Extract all the servers dead since a given time, and sort them.
|
Set<ServerName> |
DeadServer.copyServerNames() |
List<ServerName> |
ServerManager.createDestinationServersList()
Calls
ServerManager.createDestinationServersList(java.util.List<org.apache.hadoop.hbase.ServerName>) without server to exclude. |
List<ServerName> |
ServerManager.createDestinationServersList(List<ServerName> serversToExclude)
Creates a list of possible destinations for a region.
|
protected List<ServerName> |
ClusterStatusPublisher.generateDeadServersListToSend()
Create the dead server to send.
|
private List<ServerName> |
HMaster.getBackupMasters() |
protected List<Pair<ServerName,Long>> |
ClusterStatusPublisher.getDeadServers(long since)
Get the servers which died since a given timestamp.
|
List<ServerName> |
ServerManager.getDrainingServersList() |
Set<ServerName> |
MasterWalManager.getFailedServersFromLogFolders()
Deprecated.
With proc-v2, we can record the crash server with procedure store, so do not need
to scan the wal directory to find out the splitting wal directory any more. Leave
it here only because
RecoverMetaProcedure(which is also deprecated) uses
it. |
static List<ServerName> |
RegionPlacementMaintainer.getFavoredNodeList(String favoredNodesStr) |
Map<String,Pair<ServerName,List<ServerName>>> |
HbckChore.getInconsistentRegions()
Found the inconsistent regions.
|
Map<String,Pair<ServerName,List<ServerName>>> |
HbckChore.getInconsistentRegions()
Found the inconsistent regions.
|
Set<ServerName> |
MasterWalManager.getLiveServersFromWALDir()
Get Servernames that COULD BE 'alive'; excludes those that have a '-splitting' suffix as these
are already being split -- they cannot be 'alive'.
|
Map<ServerName,ServerMetrics> |
ServerManager.getOnlineServers() |
List<ServerName> |
ServerManager.getOnlineServersList() |
List<ServerName> |
ServerManager.getOnlineServersListWithPredicator(List<ServerName> keys,
Predicate<ServerMetrics> idleServerPredicator) |
Map<String,ServerName> |
HbckChore.getOrphanRegionsOnRS() |
Map<ServerName,List<RegionInfo>> |
SnapshotOfRegionAssignmentFromMeta.getPrimaryToRegionInfoMap() |
Map<ServerName,List<RegionInfo>> |
SnapshotOfRegionAssignmentFromMeta.getRegionServerToRegionMap()
Get regionserver to region map
|
Map<RegionInfo,ServerName> |
SnapshotOfRegionAssignmentFromMeta.getRegionToRegionServerMap()
Get region to region server map
|
Map<ServerName,List<RegionInfo>> |
SnapshotOfRegionAssignmentFromMeta.getSecondaryToRegionInfoMap() |
private Pair<ServerName,org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.RegionServerInfo> |
RegionServerTracker.getServerInfo(String name) |
Set<ServerName> |
MasterWalManager.getServerNamesFromWALDirPath(org.apache.hadoop.fs.PathFilter filter) |
Set<ServerName> |
MasterWalManager.getSplittingServersFromWALDir()
Get Servernames which are currently splitting; paths have a '-splitting' suffix.
|
Map<ServerName,List<RegionInfo>> |
SnapshotOfRegionAssignmentFromMeta.getTertiaryToRegionInfoMap() |
List<Pair<RegionInfo,ServerName>> |
CatalogJanitor.Report.getUnknownServers() |
List<ServerName> |
HMaster.listDecommissionedRegionServers()
List region servers marked as decommissioned (previously called 'draining') to not get regions
assigned to them.
|
Map<ServerName,List<RegionInfo>> |
LoadBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers)
Assign regions to the previously hosting region server
|
Map<ServerName,List<RegionInfo>> |
LoadBalancer.roundRobinAssignment(List<RegionInfo> regions,
List<ServerName> servers)
Perform a Round Robin assignment of regions.
|
| Modifier and Type | Method and Description |
|---|---|
void |
DeadServer.add(ServerName sn)
Adds the server to the dead server list if it's not there already.
|
private void |
SnapshotOfRegionAssignmentFromMeta.addAssignment(RegionInfo regionInfo,
ServerName server) |
private void |
SnapshotOfRegionAssignmentFromMeta.addPrimaryAssignment(RegionInfo regionInfo,
ServerName server) |
private void |
SnapshotOfRegionAssignmentFromMeta.addSecondaryAssignment(RegionInfo regionInfo,
ServerName server) |
boolean |
ServerManager.addServerToDrainList(ServerName sn)
Add the server to the drain list.
|
private void |
SnapshotOfRegionAssignmentFromMeta.addTeritiaryAssignment(RegionInfo regionInfo,
ServerName server) |
void |
MasterWalManager.archiveMetaLog(ServerName serverName)
For meta region open and closed normally on a server, it may leave some meta
WAL in the server's wal dir.
|
(package private) boolean |
ServerManager.checkAndRecordNewServer(ServerName serverName,
ServerMetrics sl)
Check is a server of same host and port already exists,
if not, or the existed one got a smaller start code, record it.
|
private void |
ServerManager.checkClockSkew(ServerName serverName,
long serverCurrentTime)
Checks if the clock skew between the server and the master.
|
private void |
ServerManager.checkIsDead(ServerName serverName,
String what)
If this server is on the dead list, reject it with a YouAreDeadException.
|
void |
DeadServer.cleanAllPreviousInstances(ServerName newServerName) |
boolean |
DeadServer.cleanPreviousInstance(ServerName newServerName)
A dead server that comes back alive has a different start code.
|
static void |
ServerManager.closeRegionSilentlyAndWait(ClusterConnection connection,
ServerName server,
RegionInfo region,
long timeout)
Contacts a region server and waits up to timeout ms
to close the region.
|
private static int |
RegionPlan.compareServerName(ServerName left,
ServerName right) |
private boolean |
MasterRpcServices.containMetaWals(ServerName serverName) |
(package private) boolean |
ServerManager.expire(ServerName serverName) |
boolean |
ServerManager.expireServer(ServerName serverName)
Expire the passed server.
|
private ServerName |
ServerManager.findServerWithSameHostnamePortWithLock(ServerName serverName)
Assumes onlineServers is locked.
|
void |
DeadServer.finish(ServerName sn)
Complete processing for this dead server.
|
int |
ServerManager.getInfoPort(ServerName serverName) |
ServerMetrics |
ServerManager.getLoad(ServerName serverName) |
String |
RackManager.getRack(ServerName server)
Get the name of the rack containing a server, according to the DNS to
switch mapping.
|
int |
HMaster.getRegionServerInfoPort(ServerName sn) |
String |
MasterServices.getRegionServerVersion(ServerName sn) |
String |
HMaster.getRegionServerVersion(ServerName sn) |
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface |
ServerManager.getRsAdmin(ServerName sn) |
int |
ServerManager.getServerVersion(ServerName serverName)
May return 0 when server is not online.
|
Date |
DeadServer.getTimeOfDeath(ServerName deadServerName)
Get the time when a server died
|
(package private) org.apache.hadoop.fs.Path |
MasterWalManager.getWALDirectoryName(ServerName serverName)
Depends on current FS Layout!
|
(package private) void |
SplitLogManager.handleDeadWorker(ServerName workerName) |
void |
SplitLogManager.Task.heartbeat(long time,
int version,
ServerName worker) |
boolean |
RegionState.isClosingOrClosedOnServer(ServerName sn) |
boolean |
DeadServer.isDeadServer(ServerName serverName) |
boolean |
RegionState.isMergingNewOnServer(ServerName sn) |
boolean |
RegionState.isMergingNewOrOfflineOnServer(ServerName sn) |
boolean |
RegionState.isMergingNewOrOpenedOnServer(ServerName sn) |
boolean |
RegionState.isMergingOnServer(ServerName sn) |
boolean |
RegionState.isOnServer(ServerName sn) |
boolean |
RegionState.isOpenedOnServer(ServerName sn) |
boolean |
RegionState.isOpeningOrFailedOpenOnServer(ServerName sn) |
boolean |
RegionState.isOpeningOrOpenedOnServer(ServerName sn) |
boolean |
DeadServer.isProcessingServer(ServerName serverName) |
boolean |
ServerManager.isServerDead(ServerName serverName)
Check if a server is known to be dead.
|
boolean |
ServerManager.isServerOnline(ServerName serverName) |
boolean |
RegionState.isSplittingNewOnServer(ServerName sn) |
boolean |
RegionState.isSplittingOnServer(ServerName sn) |
boolean |
RegionState.isSplittingOrOpenedOnServer(ServerName sn) |
boolean |
RegionState.isSplittingOrSplitOnServer(ServerName sn) |
(package private) boolean |
MasterWalManager.isWALDirectoryNameWithWALs(ServerName serverName) |
boolean |
ServerManager.moveFromOnlineToDeadServers(ServerName sn) |
void |
DeadServer.notifyServer(ServerName sn)
Notify that we started processing this dead server.
|
void |
MasterCoprocessorHost.postMove(RegionInfo region,
ServerName srcServer,
ServerName destServer) |
void |
MasterCoprocessorHost.postRecommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames) |
void |
MasterCoprocessorHost.preMove(RegionInfo region,
ServerName srcServer,
ServerName destServer) |
void |
MasterCoprocessorHost.preRecommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames) |
void |
HMaster.recommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames)
Remove decommission marker (previously called 'draining') from a region server to allow regions
assignments.
|
(package private) void |
ServerManager.recordNewServerWithLock(ServerName serverName,
ServerMetrics sl)
Adds the onlineServers list.
|
void |
LoadBalancer.regionOnline(RegionInfo regionInfo,
ServerName sn)
Marks the region as online at balancer.
|
void |
AssignmentListener.regionOpened(RegionInfo regionInfo,
ServerName serverName)
The region was opened on the specified server.
|
void |
ServerManager.regionServerReport(ServerName sn,
ServerMetrics sl) |
private void |
DrainingServerTracker.remove(ServerName sn) |
boolean |
DeadServer.removeDeadServer(ServerName deadServerName)
remove the specified dead server
|
boolean |
ServerManager.removeServerFromDrainList(ServerName sn) |
void |
ServerManager.sendRegionWarmup(ServerName server,
RegionInfo region)
Sends a WARMUP RPC to the specified server to warmup the specified region.
|
default void |
ServerListener.serverAdded(ServerName serverName)
The server has joined the cluster.
|
default void |
ServerListener.serverRemoved(ServerName serverName)
The server was removed from the cluster.
|
void |
RegionPlan.setDestination(ServerName dest)
Set the destination server for the plan for this region.
|
private boolean |
MasterRpcServices.shouldSubmitSCP(ServerName serverName) |
void |
MasterWalManager.splitLog(ServerName serverName) |
void |
MasterWalManager.splitMetaLog(ServerName serverName)
Specialized method to handle the splitting for meta WAL
|
private void |
ServerManager.updateLastFlushedSequenceIds(ServerName sn,
ServerMetrics hsl)
Updates last flushed sequence Ids for the regions on server sn
|
| Modifier and Type | Method and Description |
|---|---|
List<RegionPlan> |
LoadBalancer.balanceCluster(Map<ServerName,List<RegionInfo>> clusterState)
Perform the major balance operation
|
List<RegionPlan> |
LoadBalancer.balanceCluster(TableName tableName,
Map<ServerName,List<RegionInfo>> clusterState)
Perform the major balance operation
|
(package private) List<org.apache.hadoop.fs.Path> |
MasterWalManager.createAndGetLogDirs(Set<ServerName> serverNames)
Finds WAL dirs for
serverNames and renames them with '-splitting' suffix. |
List<ServerName> |
ServerManager.createDestinationServersList(List<ServerName> serversToExclude)
Creates a list of possible destinations for a region.
|
void |
HMaster.decommissionRegionServers(List<ServerName> servers,
boolean offload)
Mark region server(s) as decommissioned (previously called 'draining') to prevent additional
regions from getting assigned to them.
|
(package private) void |
ServerManager.findOutDeadServersAndProcess(Set<ServerName> deadServersFromPE,
Set<ServerName> liveServersFromWALDir)
Find out the region servers crashed between the crash of the previous master instance and the
current master instance and schedule SCP for them.
|
(package private) void |
ServerManager.findOutDeadServersAndProcess(Set<ServerName> deadServersFromPE,
Set<ServerName> liveServersFromWALDir)
Find out the region servers crashed between the crash of the previous master instance and the
current master instance and schedule SCP for them.
|
List<ServerName> |
ServerManager.getOnlineServersListWithPredicator(List<ServerName> keys,
Predicate<ServerMetrics> idleServerPredicator) |
List<String> |
RackManager.getRack(List<ServerName> servers)
Same as
RackManager.getRack(ServerName) except that a list is passed |
(package private) void |
SplitLogManager.handleDeadWorkers(Set<ServerName> serverNames) |
void |
MasterCoprocessorHost.postClearDeadServers(List<ServerName> servers,
List<ServerName> notClearedServers) |
void |
MasterCoprocessorHost.postClearDeadServers(List<ServerName> servers,
List<ServerName> notClearedServers) |
void |
MasterCoprocessorHost.postDecommissionRegionServers(List<ServerName> servers,
boolean offload) |
void |
MasterCoprocessorHost.preDecommissionRegionServers(List<ServerName> servers,
boolean offload) |
private void |
AssignmentVerificationReport.printHServerAddressSet(Set<ServerName> serverSet) |
ServerName |
LoadBalancer.randomAssignment(RegionInfo regionInfo,
List<ServerName> servers)
Get a random region server from the list
|
Map<ServerName,List<RegionInfo>> |
LoadBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers)
Assign regions to the previously hosting region server
|
Map<ServerName,List<RegionInfo>> |
LoadBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers)
Assign regions to the previously hosting region server
|
Map<ServerName,List<RegionInfo>> |
LoadBalancer.roundRobinAssignment(List<RegionInfo> regions,
List<ServerName> servers)
Perform a Round Robin assignment of regions.
|
void |
LoadBalancer.setClusterLoad(Map<TableName,Map<ServerName,List<RegionInfo>>> ClusterLoad)
Pass RegionStates and allow balancer to set the current cluster load.
|
void |
MasterWalManager.splitLog(Set<ServerName> serverNames) |
void |
MasterWalManager.splitLog(Set<ServerName> serverNames,
org.apache.hadoop.fs.PathFilter filter)
This method is the base split method that splits WAL files matching a filter.
|
long |
SplitLogManager.splitLogDistributed(Set<ServerName> serverNames,
List<org.apache.hadoop.fs.Path> logDirs,
org.apache.hadoop.fs.PathFilter filter)
The caller will block until all the hbase:meta log files of the given region server have been
processed - successfully split or an error is encountered - by an available worker region
server.
|
void |
MasterWalManager.splitMetaLog(Set<ServerName> serverNames)
Specialized method to handle the splitting for meta WAL
|
void |
RegionServerTracker.start(Set<ServerName> deadServersFromPE,
Set<ServerName> liveServersFromWALDir,
Set<ServerName> splittingServersFromWALDir)
Starts the tracking of online RegionServers.
|
void |
RegionServerTracker.start(Set<ServerName> deadServersFromPE,
Set<ServerName> liveServersFromWALDir,
Set<ServerName> splittingServersFromWALDir)
Starts the tracking of online RegionServers.
|
void |
RegionServerTracker.start(Set<ServerName> deadServersFromPE,
Set<ServerName> liveServersFromWALDir,
Set<ServerName> splittingServersFromWALDir)
Starts the tracking of online RegionServers.
|
| Constructor and Description |
|---|
ActiveMasterManager(ZKWatcher watcher,
ServerName sn,
Server master) |
RegionPlan(RegionInfo hri,
ServerName source,
ServerName dest)
Instantiate a plan for a region move, moving the specified region from
the specified source server to the specified destination server.
|
RegionState(RegionInfo region,
RegionState.State state,
long stamp,
ServerName serverName) |
RegionState(RegionInfo region,
RegionState.State state,
long stamp,
ServerName serverName,
long ritDuration) |
RegionState(RegionInfo region,
RegionState.State state,
ServerName serverName) |
| Modifier and Type | Field and Description |
|---|---|
protected ServerName |
UnassignProcedure.destinationServer
The Server we will subsequently assign the region too (can be null).
|
protected ServerName |
UnassignProcedure.hostingServer
Where to send the unassign RPC.
|
private ServerName |
RegionStates.RegionStateNode.lastHost |
private ServerName |
MergeTableRegionsProcedure.regionLocation |
private ServerName |
RegionStates.RegionStateNode.regionLocation |
private ServerName |
RegionStates.ServerStateNode.serverName |
protected ServerName |
AssignProcedure.targetServer
Gets set as desired target on move, merge, etc., when we want to go to a particular server.
|
| Modifier and Type | Field and Description |
|---|---|
private Map<ServerName,Set<byte[]>> |
AssignmentManager.rsReports |
private ConcurrentHashMap<ServerName,RegionStates.ServerStateNode> |
RegionStates.serverMap |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
RegionStates.RegionStateNode.getLastHost() |
private ServerName |
SplitTableRegionProcedure.getParentRegionServerName(MasterProcedureEnv env) |
ServerName |
RegionStates.RegionStateNode.getRegionLocation() |
(package private) static ServerName |
RegionStateStore.getRegionServer(Result r,
int replicaId)
Returns the
ServerName from catalog table Result
where the region is transitioning. |
ServerName |
RegionStates.getRegionServerOfRegion(RegionInfo regionInfo) |
ServerName |
UnassignProcedure.getServer(MasterProcedureEnv env) |
ServerName |
AssignProcedure.getServer(MasterProcedureEnv env) |
abstract ServerName |
RegionTransitionProcedure.getServer(MasterProcedureEnv env)
Used by ServerCrashProcedure to see if this Assign/Unassign needs processing.
|
ServerName |
RegionStates.ServerStateNode.getServerName() |
private ServerName |
MergeTableRegionsProcedure.getServerName(MasterProcedureEnv env)
The procedure could be restarted from a different machine.
|
ServerName |
RegionStates.RegionStateNode.offline()
Put region into OFFLINE mode (set state and clear location).
|
ServerName |
RegionStates.RegionStateNode.setRegionLocation(ServerName serverName) |
| Modifier and Type | Method and Description |
|---|---|
Map<TableName,Map<ServerName,List<RegionInfo>>> |
RegionStates.getAssignmentsByTable() |
Map<TableName,Map<ServerName,List<RegionInfo>>> |
RegionStates.getAssignmentsByTable(boolean forceByCluster)
This is an EXPENSIVE clone.
|
List<ServerName> |
AssignmentManager.getExcludedServersForSystemTable()
Get a list of servers that this region cannot be assigned to.
|
List<ServerName> |
AssignmentManager.getFavoredNodes(RegionInfo regionInfo) |
Map<RegionInfo,ServerName> |
RegionStates.getRegionAssignments() |
Map<ServerName,Set<byte[]>> |
AssignmentManager.getRSReports() |
Map<ServerName,List<RegionInfo>> |
RegionStates.getSnapShotOfAssignment(Collection<RegionInfo> regions) |
Map<ServerName,List<RegionInfo>> |
AssignmentManager.getSnapShotOfAssignment(Collection<RegionInfo> regions) |
| Modifier and Type | Method and Description |
|---|---|
protected boolean |
RegionTransitionProcedure.addToRemoteDispatcher(MasterProcedureEnv env,
ServerName targetServer)
Be careful! At the end of this method, the procedure has either succeeded
and this procedure has been set into a suspended state OR, we failed and
this procedure has been put back on the scheduler ready for another worker
to pick it up.
|
void |
AssignmentManager.assign(RegionInfo regionInfo,
ServerName sn) |
(package private) void |
AssignmentManager.checkOnlineRegionsReportForMeta(ServerName serverName,
Set<byte[]> regionNames) |
AssignProcedure |
AssignmentManager.createAssignProcedure(RegionInfo regionInfo,
ServerName targetServer) |
AssignProcedure |
AssignmentManager.createAssignProcedure(RegionInfo regionInfo,
ServerName targetServer,
boolean override) |
(package private) UnassignProcedure |
AssignmentManager.createUnassignProcedure(RegionInfo regionInfo,
ServerName destinationServer,
boolean force) |
(package private) UnassignProcedure |
AssignmentManager.createUnassignProcedure(RegionInfo regionInfo,
ServerName destinationServer,
boolean force,
boolean removeAfterUnassigning) |
(package private) RegionStates.ServerStateNode |
RegionStates.getOrCreateServer(ServerName serverName)
Be judicious calling this method.
|
(package private) static org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionInfoResponse |
Util.getRegionInfoResponse(MasterProcedureEnv env,
ServerName regionLocation,
RegionInfo hri)
Raw call to remote regionserver to get info on a particular region.
|
(package private) static org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionInfoResponse |
Util.getRegionInfoResponse(MasterProcedureEnv env,
ServerName regionLocation,
RegionInfo hri,
boolean includeBestSplitRow) |
RegionStates.ServerStateNode |
RegionStates.getServerNode(ServerName serverName) |
List<RegionInfo> |
RegionStates.getServerRegionInfoSet(ServerName serverName)
Returns the set of regions hosted by the specified server
|
private List<RegionInfo> |
AssignmentManager.getSystemTables(ServerName serverName) |
boolean |
AssignmentManager.isCarryingMeta(ServerName serverName) |
private boolean |
AssignmentManager.isCarryingRegion(ServerName serverName,
RegionInfo regionInfo) |
(package private) boolean |
AssignmentManager.isLogSplittingDone(ServerName serverName,
boolean meta)
This is a very particular check.
|
protected boolean |
RegionTransitionProcedure.isServerOnline(MasterProcedureEnv env,
ServerName serverName) |
private void |
AssignmentManager.killRegionServer(ServerName serverName) |
void |
RegionStates.logSplit(ServerName serverName)
Called after we've split all logs on a crashed Server.
|
void |
RegionStates.logSplitting(ServerName serverName)
Call this when we start log splitting for a crashed Server.
|
void |
AssignmentManager.markRegionAsMerged(RegionInfo child,
ServerName serverName,
RegionInfo[] mergeParents)
When called here, the merge has happened.
|
void |
AssignmentManager.markRegionAsSplit(RegionInfo parent,
ServerName serverName,
RegionInfo daughterA,
RegionInfo daughterB) |
void |
RegionStateStore.mergeRegions(RegionInfo child,
RegionInfo[] parents,
ServerName serverName) |
void |
RegionStates.metaLogSplit(ServerName serverName)
Called after we've split the meta logs on a crashed Server.
|
void |
RegionStates.metaLogSplitting(ServerName serverName)
Call this when we start meta log splitting a crashed Server.
|
void |
AssignmentManager.onlineRegion(RegionInfo regionInfo,
ServerName serverName) |
RemoteProcedureDispatcher.RemoteOperation |
UnassignProcedure.remoteCallBuild(MasterProcedureEnv env,
ServerName serverName) |
RemoteProcedureDispatcher.RemoteOperation |
AssignProcedure.remoteCallBuild(MasterProcedureEnv env,
ServerName serverName) |
abstract RemoteProcedureDispatcher.RemoteOperation |
RegionTransitionProcedure.remoteCallBuild(MasterProcedureEnv env,
ServerName serverName) |
void |
RegionTransitionProcedure.remoteCallCompleted(MasterProcedureEnv env,
ServerName serverName,
RemoteProcedureDispatcher.RemoteOperation response) |
boolean |
RegionTransitionProcedure.remoteCallFailed(MasterProcedureEnv env,
ServerName serverName,
IOException exception) |
RegionStates.ServerStateNode |
RegionStates.removeRegionFromServer(ServerName serverName,
RegionStates.RegionStateNode regionNode) |
void |
RegionStates.removeServer(ServerName serverName) |
void |
AssignmentManager.reportOnlineRegions(ServerName serverName,
Set<byte[]> regionNames)
the master will call this method when the RS send the regionServerReport().
|
protected void |
RegionTransitionProcedure.reportTransition(MasterProcedureEnv env,
ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
long seqId) |
private boolean |
AssignmentManager.reportTransition(RegionStates.RegionStateNode regionNode,
ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state,
long seqId) |
private void |
AssignmentManager.sendRegionOpenedNotification(RegionInfo regionInfo,
ServerName serverName) |
void |
AssignmentManager.serverAdded(ServerName serverName) |
void |
AssignmentManager.serverRemoved(ServerName serverName) |
void |
RegionStates.RegionStateNode.setLastHost(ServerName serverName) |
ServerName |
RegionStates.RegionStateNode.setRegionLocation(ServerName serverName) |
private void |
RegionStates.setServerState(ServerName serverName,
RegionStates.ServerState state) |
void |
RegionStateStore.splitRegion(RegionInfo parent,
RegionInfo hriA,
RegionInfo hriB,
ServerName serverName) |
long |
AssignmentManager.submitServerCrash(ServerName serverName,
boolean shouldSplitWal) |
private void |
RegionStateStore.updateMetaLocation(RegionInfo regionInfo,
ServerName serverName,
RegionState.State state) |
private void |
AssignmentManager.updateRegionMergeTransition(ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state,
RegionInfo merged,
RegionInfo hriA,
RegionInfo hriB) |
private void |
AssignmentManager.updateRegionSplitTransition(ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state,
RegionInfo parent,
RegionInfo hriA,
RegionInfo hriB) |
private void |
AssignmentManager.updateRegionTransition(ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state,
RegionInfo regionInfo,
long seqId)
Called when the RegionServer wants to report a Procedure transition.
|
private void |
RegionStateStore.updateUserRegionLocation(RegionInfo regionInfo,
RegionState.State state,
ServerName regionLocation,
long openSeqNum,
long pid) |
void |
RegionStateStore.RegionStateVisitor.visitRegionState(Result result,
RegionInfo regionInfo,
RegionState.State state,
ServerName regionLocation,
ServerName lastHost,
long openSeqNum) |
protected boolean |
AssignmentManager.waitServerReportEvent(ServerName serverName,
Procedure<?> proc) |
| Modifier and Type | Method and Description |
|---|---|
private void |
AssignmentManager.acceptPlan(HashMap<RegionInfo,RegionStates.RegionStateNode> regions,
Map<ServerName,List<RegionInfo>> plan) |
private AssignProcedure[] |
AssignmentManager.createAssignProcedures(Map<ServerName,List<RegionInfo>> assignments,
int size) |
private void |
AssignmentManager.processAssignmentPlans(HashMap<RegionInfo,RegionStates.RegionStateNode> regions,
HashMap<RegionInfo,ServerName> retainMap,
List<RegionInfo> hris,
List<ServerName> servers) |
private void |
AssignmentManager.processAssignmentPlans(HashMap<RegionInfo,RegionStates.RegionStateNode> regions,
HashMap<RegionInfo,ServerName> retainMap,
List<RegionInfo> hris,
List<ServerName> servers) |
| Constructor and Description |
|---|
AssignProcedure(RegionInfo regionInfo,
ServerName destinationServer) |
AssignProcedure(RegionInfo regionInfo,
ServerName destinationServer,
boolean override) |
ServerReportEvent(ServerName serverName) |
ServerStateNode(ServerName serverName) |
UnassignProcedure(RegionInfo regionInfo,
ServerName hostingServer,
boolean force,
boolean removeAfterUnassigning) |
UnassignProcedure(RegionInfo regionInfo,
ServerName hostingServer,
ServerName destinationServer,
boolean force) |
UnassignProcedure(RegionInfo regionInfo,
ServerName hostingServer,
ServerName destinationServer,
boolean override,
boolean removeAfterUnassigning) |
| Modifier and Type | Field and Description |
|---|---|
protected ServerName |
BaseLoadBalancer.masterServerName |
(package private) ServerName[] |
BaseLoadBalancer.Cluster.servers |
private ServerName |
ServerAndLoad.sn |
| Modifier and Type | Field and Description |
|---|---|
(package private) Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.Cluster.clusterState |
private Map<ServerName,List<RegionInfo>> |
ClusterLoadState.clusterState |
| Modifier and Type | Method and Description |
|---|---|
private ServerName |
FavoredStochasticBalancer.getServerFromFavoredNode(List<ServerName> servers,
ServerName fn) |
(package private) ServerName |
ServerAndLoad.getServerName() |
private ServerName |
BaseLoadBalancer.randomAssignment(BaseLoadBalancer.Cluster cluster,
RegionInfo regionInfo,
List<ServerName> servers)
Used to assign a single region to a random server.
|
ServerName |
BaseLoadBalancer.randomAssignment(RegionInfo regionInfo,
List<ServerName> servers)
Used to assign a single region to a random server.
|
ServerName |
FavoredStochasticBalancer.randomAssignment(RegionInfo regionInfo,
List<ServerName> servers) |
| Modifier and Type | Method and Description |
|---|---|
protected Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.assignMasterSystemRegions(Collection<RegionInfo> regions,
List<ServerName> servers)
If master is configured to carry system tables only, in here is
where we figure what to assign it.
|
private List<ServerName> |
BaseLoadBalancer.findIdleServers(List<ServerName> servers) |
private Map<ServerName,List<RegionInfo>> |
FavoredStochasticBalancer.generateFNForRegionsWithoutFN(FavoredNodeAssignmentHelper helper,
List<RegionInfo> regions) |
(package private) Map<ServerName,List<RegionInfo>> |
ClusterLoadState.getClusterState() |
List<ServerName> |
FavoredStochasticBalancer.getFavoredNodes(RegionInfo regionInfo) |
private Set<ServerName> |
FavoredStochasticBalancer.getInheritedFNForDaughter(FavoredNodeAssignmentHelper helper,
List<ServerName> parentFavoredNodes,
FavoredNodesPlan.Position primary,
FavoredNodesPlan.Position secondary) |
private List<ServerName> |
FavoredStochasticBalancer.getOnlineFavoredNodes(List<ServerName> onlineServers,
List<ServerName> serversWithoutStartCodes) |
protected Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.getRegionAssignmentsByServer(Collection<RegionInfo> regions) |
protected List<ServerName> |
RegionLocationFinder.getTopBlockLocations(RegionInfo region) |
protected List<ServerName> |
RegionLocationFinder.getTopBlockLocations(RegionInfo region,
String currentHost)
Returns an ordered list of hosts which have better locality for this region
than the current host.
|
protected List<ServerName> |
RegionLocationFinder.mapHostNameToServerName(List<String> hosts)
Map hostname to ServerName, The output ServerName list will have the same
order as input hosts.
|
Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers)
Generates a bulk assignment startup plan, attempting to reuse the existing
assignment information from META, but adjusting for the specified list of
available/online servers available for assignment.
|
Map<ServerName,List<RegionInfo>> |
FavoredStochasticBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers) |
Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.roundRobinAssignment(List<RegionInfo> regions,
List<ServerName> servers)
Generates a bulk assignment plan to be used on cluster startup using a
simple round-robin assignment.
|
Map<ServerName,List<RegionInfo>> |
FavoredStochasticBalancer.roundRobinAssignment(List<RegionInfo> regions,
List<ServerName> servers) |
private Pair<Map<ServerName,List<RegionInfo>>,List<RegionInfo>> |
FavoredStochasticBalancer.segregateRegionsAndAssignRegionsWithFavoredNodes(Collection<RegionInfo> regions,
List<ServerName> onlineServers) |
| Modifier and Type | Method and Description |
|---|---|
private void |
SimpleLoadBalancer.addRegionPlan(org.apache.hbase.thirdparty.com.google.common.collect.MinMaxPriorityQueue<RegionPlan> regionsToMove,
boolean fetchFromTail,
ServerName sn,
List<RegionPlan> regionsToReturn)
Add a region from the head or tail to the List of regions to return.
|
private void |
FavoredStochasticBalancer.addRegionToMap(Map<ServerName,List<RegionInfo>> assignmentMapForFavoredNodes,
RegionInfo region,
ServerName host) |
private void |
FavoredStochasticBalancer.assignRegionToAvailableFavoredNode(Map<ServerName,List<RegionInfo>> assignmentMapForFavoredNodes,
RegionInfo region,
ServerName primaryHost,
ServerName secondaryHost,
ServerName tertiaryHost) |
(package private) void |
BaseLoadBalancer.Cluster.doAssignRegion(RegionInfo regionInfo,
ServerName serverName) |
String |
BaseLoadBalancer.DefaultRackManager.getRack(ServerName server) |
private ServerName |
FavoredStochasticBalancer.getServerFromFavoredNode(List<ServerName> servers,
ServerName fn) |
void |
BaseLoadBalancer.regionOnline(RegionInfo regionInfo,
ServerName sn) |
(package private) boolean |
BaseLoadBalancer.Cluster.wouldLowerAvailability(RegionInfo regionInfo,
ServerName serverName)
Return true if the placement of region on server would lower the availability
of the region in question
|
| Modifier and Type | Method and Description |
|---|---|
private void |
FavoredStochasticBalancer.addRegionToMap(Map<ServerName,List<RegionInfo>> assignmentMapForFavoredNodes,
RegionInfo region,
ServerName host) |
protected Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.assignMasterSystemRegions(Collection<RegionInfo> regions,
List<ServerName> servers)
If master is configured to carry system tables only, in here is
where we figure what to assign it.
|
private void |
FavoredStochasticBalancer.assignRegionToAvailableFavoredNode(Map<ServerName,List<RegionInfo>> assignmentMapForFavoredNodes,
RegionInfo region,
ServerName primaryHost,
ServerName secondaryHost,
ServerName tertiaryHost) |
List<RegionPlan> |
StochasticLoadBalancer.balanceCluster(Map<ServerName,List<RegionInfo>> clusterState)
Given the cluster state this will try and approach an optimal balance.
|
List<RegionPlan> |
SimpleLoadBalancer.balanceCluster(Map<ServerName,List<RegionInfo>> clusterMap)
Generate a global load balancing plan according to the specified map of
server information to the most loaded regions of each server.
|
List<RegionPlan> |
FavoredStochasticBalancer.balanceCluster(Map<ServerName,List<RegionInfo>> clusterState) |
List<RegionPlan> |
StochasticLoadBalancer.balanceCluster(TableName tableName,
Map<ServerName,List<RegionInfo>> clusterState) |
List<RegionPlan> |
SimpleLoadBalancer.balanceCluster(TableName tableName,
Map<ServerName,List<RegionInfo>> clusterState) |
protected List<RegionPlan> |
BaseLoadBalancer.balanceMasterRegions(Map<ServerName,List<RegionInfo>> clusterMap)
Balance the regions that should be on master regionserver.
|
void |
SimpleLoadBalancer.balanceOverall(List<RegionPlan> regionsToReturn,
Map<ServerName,SimpleLoadBalancer.BalanceInfo> serverBalanceInfo,
boolean fetchFromTail,
org.apache.hbase.thirdparty.com.google.common.collect.MinMaxPriorityQueue<RegionPlan> regionsToMove,
int max,
int min)
If we need to balanceoverall, we need to add one more round to peel off one region from each max.
|
protected BaseLoadBalancer.Cluster |
BaseLoadBalancer.createCluster(List<ServerName> servers,
Collection<RegionInfo> regions) |
private List<ServerName> |
BaseLoadBalancer.findIdleServers(List<ServerName> servers) |
void |
FavoredStochasticBalancer.generateFavoredNodesForDaughter(List<ServerName> servers,
RegionInfo parent,
RegionInfo regionA,
RegionInfo regionB) |
private int |
FavoredStochasticBalancer.FavoredNodeLocalityPicker.getDifferentFavoredNode(BaseLoadBalancer.Cluster cluster,
List<ServerName> favoredNodes,
int currentServer) |
private Set<ServerName> |
FavoredStochasticBalancer.getInheritedFNForDaughter(FavoredNodeAssignmentHelper helper,
List<ServerName> parentFavoredNodes,
FavoredNodesPlan.Position primary,
FavoredNodesPlan.Position secondary) |
private List<ServerName> |
FavoredStochasticBalancer.getOnlineFavoredNodes(List<ServerName> onlineServers,
List<ServerName> serversWithoutStartCodes) |
private List<ServerName> |
FavoredStochasticBalancer.getOnlineFavoredNodes(List<ServerName> onlineServers,
List<ServerName> serversWithoutStartCodes) |
private ServerName |
FavoredStochasticBalancer.getServerFromFavoredNode(List<ServerName> servers,
ServerName fn) |
private void |
FavoredStochasticBalancer.mergeAssignmentMaps(Map<ServerName,List<RegionInfo>> assignmentMap,
Map<ServerName,List<RegionInfo>> otherAssignments) |
private void |
FavoredStochasticBalancer.mergeAssignmentMaps(Map<ServerName,List<RegionInfo>> assignmentMap,
Map<ServerName,List<RegionInfo>> otherAssignments) |
private int |
FavoredStochasticBalancer.FavoredNodeLoadPicker.pickLeastLoadedFNServer(BaseLoadBalancer.Cluster cluster,
List<ServerName> favoredNodes,
int currentServerIndex) |
private ServerName |
BaseLoadBalancer.randomAssignment(BaseLoadBalancer.Cluster cluster,
RegionInfo regionInfo,
List<ServerName> servers)
Used to assign a single region to a random server.
|
ServerName |
BaseLoadBalancer.randomAssignment(RegionInfo regionInfo,
List<ServerName> servers)
Used to assign a single region to a random server.
|
ServerName |
FavoredStochasticBalancer.randomAssignment(RegionInfo regionInfo,
List<ServerName> servers) |
Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers)
Generates a bulk assignment startup plan, attempting to reuse the existing
assignment information from META, but adjusting for the specified list of
available/online servers available for assignment.
|
Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers)
Generates a bulk assignment startup plan, attempting to reuse the existing
assignment information from META, but adjusting for the specified list of
available/online servers available for assignment.
|
Map<ServerName,List<RegionInfo>> |
FavoredStochasticBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers) |
Map<ServerName,List<RegionInfo>> |
FavoredStochasticBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers) |
private void |
BaseLoadBalancer.roundRobinAssignment(BaseLoadBalancer.Cluster cluster,
List<RegionInfo> regions,
List<RegionInfo> unassignedRegions,
List<ServerName> servers,
Map<ServerName,List<RegionInfo>> assignments)
Round robin a list of regions to a list of servers
|
private void |
BaseLoadBalancer.roundRobinAssignment(BaseLoadBalancer.Cluster cluster,
List<RegionInfo> regions,
List<RegionInfo> unassignedRegions,
List<ServerName> servers,
Map<ServerName,List<RegionInfo>> assignments)
Round robin a list of regions to a list of servers
|
Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.roundRobinAssignment(List<RegionInfo> regions,
List<ServerName> servers)
Generates a bulk assignment plan to be used on cluster startup using a
simple round-robin assignment.
|
Map<ServerName,List<RegionInfo>> |
FavoredStochasticBalancer.roundRobinAssignment(List<RegionInfo> regions,
List<ServerName> servers) |
private Pair<Map<ServerName,List<RegionInfo>>,List<RegionInfo>> |
FavoredStochasticBalancer.segregateRegionsAndAssignRegionsWithFavoredNodes(Collection<RegionInfo> regions,
List<ServerName> onlineServers) |
void |
BaseLoadBalancer.setClusterLoad(Map<TableName,Map<ServerName,List<RegionInfo>>> clusterLoad) |
void |
SimpleLoadBalancer.setClusterLoad(Map<TableName,Map<ServerName,List<RegionInfo>>> clusterLoad) |
private void |
FavoredStochasticBalancer.updateFavoredNodesForRegion(RegionInfo regionInfo,
List<ServerName> newFavoredNodes) |
| Constructor and Description |
|---|
ServerAndLoad(ServerName sn,
int load) |
| Constructor and Description |
|---|
Cluster(Collection<RegionInfo> unassignedRegions,
Map<ServerName,List<RegionInfo>> clusterState,
Map<String,Deque<BalancerRegionLoad>> loads,
RegionLocationFinder regionFinder,
RackManager rackManager) |
Cluster(Map<ServerName,List<RegionInfo>> clusterState,
Map<String,Deque<BalancerRegionLoad>> loads,
RegionLocationFinder regionFinder,
RackManager rackManager) |
ClusterLoadState(Map<ServerName,List<RegionInfo>> clusterState) |
| Modifier and Type | Field and Description |
|---|---|
private ServerName |
RSProcedureDispatcher.RegionCloseOperation.destinationServer |
private ServerName |
RecoverMetaProcedure.failedMetaServer
Deprecated.
|
private ServerName |
RSProcedureDispatcher.AbstractRSRemoteCall.serverName |
private ServerName |
ServerCrashException.serverName |
private ServerName |
ServerCrashProcedure.serverName
Name of the crashed server to process.
|
| Modifier and Type | Field and Description |
|---|---|
private List<ServerName> |
RSProcedureDispatcher.RegionOpenOperation.favoredNodes |
private Map<ServerName,LockAndQueue> |
SchemaLocking.serverLocks |
private FairQueue<ServerName> |
MasterProcedureScheduler.serverRunQueue |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
RSProcedureDispatcher.RegionCloseOperation.getDestinationServer() |
ServerName |
ServerProcedureInterface.getServerName() |
protected ServerName |
RSProcedureDispatcher.AbstractRSRemoteCall.getServerName() |
ServerName |
ServerCrashProcedure.getServerName() |
private static ServerName |
MasterProcedureScheduler.getServerName(Procedure proc) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
RSProcedureDispatcher.abortPendingOperations(ServerName serverName,
Set<RemoteProcedureDispatcher.RemoteProcedure> operations) |
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.CloseRegionRequest |
RSProcedureDispatcher.RegionCloseOperation.buildCloseRegionRequest(ServerName serverName) |
protected static org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.OpenRegionRequest |
RSProcedureDispatcher.buildOpenRegionRequest(MasterProcedureEnv env,
ServerName serverName,
List<RSProcedureDispatcher.RegionOpenOperation> operations) |
(package private) LockAndQueue |
SchemaLocking.getServerLock(ServerName serverName) |
private ServerQueue |
MasterProcedureScheduler.getServerQueue(ServerName serverName,
ServerProcedureInterface proc) |
private void |
RecoverMetaProcedure.handleRIT(MasterProcedureEnv env,
RegionInfo ri,
ServerName crashedServerName)
Deprecated.
Is the region stuck assigning to this failedMetaServer? If so, cancel the call
just as we do over in ServerCrashProcedure#handleRIT except less to do here; less context
to carry.
|
protected void |
RSProcedureDispatcher.remoteDispatch(ServerName serverName,
Set<RemoteProcedureDispatcher.RemoteProcedure> remoteProcedures) |
(package private) LockAndQueue |
SchemaLocking.removeServerLock(ServerName serverName) |
private void |
MasterProcedureScheduler.removeServerQueue(ServerName serverName) |
private org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.CloseRegionResponse |
RSProcedureDispatcher.CloseRegionRemoteCall.sendRequest(ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.CloseRegionRequest request) |
protected org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.ExecuteProceduresResponse |
RSProcedureDispatcher.ExecuteProceduresRemoteCall.sendRequest(ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.ExecuteProceduresRequest request) |
private org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.OpenRegionResponse |
RSProcedureDispatcher.OpenRegionRemoteCall.sendRequest(ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.OpenRegionRequest request) |
void |
RSProcedureDispatcher.serverAdded(ServerName serverName) |
void |
RSProcedureDispatcher.serverRemoved(ServerName serverName) |
void |
RSProcedureDispatcher.splitAndResolveOperation(ServerName serverName,
Set<RemoteProcedureDispatcher.RemoteProcedure> remoteProcedures,
RSProcedureDispatcher.RemoteProcedureResolver resolver)
Fetches
RemoteProcedureDispatcher.RemoteOperations
from the given remoteProcedures and groups them by class of the returned operation. |
private void |
MasterProcedureScheduler.tryCleanupServerQueue(ServerName serverName,
Procedure<?> proc) |
boolean |
MasterProcedureScheduler.waitServerExclusiveLock(Procedure procedure,
ServerName serverName)
Try to acquire the exclusive lock on the specified server.
|
void |
MasterProcedureScheduler.wakeServerExclusiveLock(Procedure procedure,
ServerName serverName)
Wake the procedures waiting for the specified server
|
| Constructor and Description |
|---|
AbstractRSRemoteCall(ServerName serverName) |
CloseRegionRemoteCall(ServerName serverName,
RSProcedureDispatcher.RegionCloseOperation operation) |
DeadRSRemoteCall(ServerName serverName,
Set<RemoteProcedureDispatcher.RemoteProcedure> remoteProcedures) |
ExecuteProceduresRemoteCall(ServerName serverName,
Set<RemoteProcedureDispatcher.RemoteProcedure> remoteProcedures) |
OpenRegionRemoteCall(ServerName serverName,
List<RSProcedureDispatcher.RegionOpenOperation> operations) |
RecoverMetaProcedure(ServerName failedMetaServer,
boolean shouldSplitLog)
Deprecated.
Call this constructor to queue up a
RecoverMetaProcedure in response to meta
carrying server crash |
RecoverMetaProcedure(ServerName failedMetaServer,
boolean shouldSplitLog,
ProcedurePrepareLatch latch)
Deprecated.
Constructor with latch, for blocking/ sync usage
|
RegionCloseOperation(RemoteProcedureDispatcher.RemoteProcedure remoteProcedure,
RegionInfo regionInfo,
ServerName destinationServer) |
ServerCrashException(long procId,
ServerName serverName) |
ServerCrashProcedure(MasterProcedureEnv env,
ServerName serverName,
boolean shouldSplitWal,
boolean carryingMeta)
Call this constructor queuing up a Procedure.
|
ServerQueue(ServerName serverName,
int priority,
LockStatus serverLock) |
| Constructor and Description |
|---|
RegionOpenOperation(RemoteProcedureDispatcher.RemoteProcedure remoteProcedure,
RegionInfo regionInfo,
List<ServerName> favoredNodes,
boolean openForReplay) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
EnabledTableSnapshotHandler.snapshotRegions(List<Pair<RegionInfo,ServerName>> regions)
This method kicks off a snapshot procedure.
|
void |
DisabledTableSnapshotHandler.snapshotRegions(List<Pair<RegionInfo,ServerName>> regionsAndLocations) |
protected abstract void |
TakeSnapshotHandler.snapshotRegions(List<Pair<RegionInfo,ServerName>> regions)
Snapshot the specified regions
|
| Modifier and Type | Method and Description |
|---|---|
static Map<TableName,SpaceQuotaSnapshot> |
QuotaTableUtil.getRegionServerQuotaSnapshots(Connection conn,
ServerName regionServer)
Fetches the observed
SpaceQuotaSnapshots observed by a RegionServer. |
| Modifier and Type | Field and Description |
|---|---|
protected ServerName |
HRegionServer.serverName
The server name the Master sees us as.
|
private ServerName |
HRegionServer.MovedRegionInfo.serverName |
| Modifier and Type | Method and Description |
|---|---|
protected ServerName |
HRegionServer.createRegionServerStatusStub()
Get the current master from ZooKeeper and open the RPC connection to it.
|
protected ServerName |
HRegionServer.createRegionServerStatusStub(boolean refresh)
Get the current master from ZooKeeper and open the RPC connection to it.
|
ServerName |
RegionCoprocessorHost.RegionEnvironment.getServerName() |
ServerName |
RegionServerCoprocessorHost.RegionServerEnvironment.getServerName() |
ServerName |
HRegionServer.getServerName() |
ServerName |
HRegionServer.MovedRegionInfo.getServerName() |
| Modifier and Type | Method and Description |
|---|---|
protected void |
HRegionServer.addToMovedRegions(String encodedName,
ServerName destination,
long closeSeqNum) |
protected boolean |
HRegionServer.closeRegion(String encodedName,
boolean abort,
ServerName sn)
Close asynchronously a region, can be called from the master or internally by the regionserver
when stopping.
|
boolean |
MutableOnlineRegions.removeRegion(HRegion r,
ServerName destination)
Removes the given Region from the list of onlineRegions.
|
boolean |
HRegionServer.removeRegion(HRegion r,
ServerName destination) |
| Constructor and Description |
|---|
MovedRegionInfo(ServerName serverName,
long closeSeqNum) |
ScannerIdGenerator(ServerName serverName) |
| Modifier and Type | Field and Description |
|---|---|
private ServerName |
CloseRegionHandler.destination |
private ServerName |
WALSplitterHandler.serverName |
| Constructor and Description |
|---|
CloseRegionHandler(Server server,
RegionServerServices rsServices,
RegionInfo regionInfo,
boolean abort,
EventType eventType,
ServerName destination) |
CloseRegionHandler(Server server,
RegionServerServices rsServices,
RegionInfo regionInfo,
boolean abort,
ServerName destination)
This method used internally by the RegionServer to close out regions.
|
| Modifier and Type | Field and Description |
|---|---|
private List<ServerName> |
ReplicationQueueInfo.deadRegionServers |
private List<ServerName> |
HBaseReplicationEndpoint.regionServers |
| Modifier and Type | Method and Description |
|---|---|
protected static List<ServerName> |
HBaseReplicationEndpoint.fetchSlavesAddresses(ZKWatcher zkw)
Get the list of all the region servers from the specified peer
|
List<ServerName> |
ReplicationQueueInfo.getDeadRegionServers() |
List<ServerName> |
HBaseReplicationEndpoint.getRegionServers()
Get a list of all the addresses of all the region servers
for this peer cluster
|
| Modifier and Type | Method and Description |
|---|---|
private static void |
ReplicationQueueInfo.extractDeadServersFromZNodeString(String deadServerListStr,
List<ServerName> result)
Parse dead server names from znode string servername can contain "-" such as
"ip-10-46-221-101.ec2.internal", so we need skip some "-" during parsing for the following
cases: 2-ip-10-46-221-101.ec2.internal,52170,1364333181125-<server name>-...
|
void |
HBaseReplicationEndpoint.setRegionServers(List<ServerName> regionServers)
Set the list of region servers for that peer
|
| Modifier and Type | Field and Description |
|---|---|
private ServerName |
WALEntryStream.serverName |
private ServerName |
ReplicationSinkManager.SinkPeer.serverName |
| Modifier and Type | Field and Description |
|---|---|
private Map<ServerName,Integer> |
ReplicationSinkManager.badReportCounts |
private List<ServerName> |
ReplicationSinkManager.sinks |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
ReplicationSyncUp.DummyServer.getServerName() |
(package private) ServerName |
ReplicationSinkManager.SinkPeer.getServerName() |
ServerName |
RecoveredReplicationSource.getServerWALsBelongTo() |
ServerName |
ReplicationSourceInterface.getServerWALsBelongTo()
The queue of WALs only belong to one region server.
|
ServerName |
ReplicationSource.getServerWALsBelongTo() |
| Modifier and Type | Method and Description |
|---|---|
protected List<ServerName> |
ReplicationSinkManager.getSinksForTesting() |
| Constructor and Description |
|---|
SinkPeer(ServerName serverName,
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface regionServer) |
WALEntryStream(PriorityBlockingQueue<org.apache.hadoop.fs.Path> logQueue,
org.apache.hadoop.conf.Configuration conf,
long startPosition,
WALFileLengthProvider walFileLengthProvider,
ServerName serverName,
MetricsSource metrics)
Create an entry stream over the given queue at the given start position
|
| Modifier and Type | Method and Description |
|---|---|
private ServerName |
RSGroupBasedLoadBalancer.findServerForRegion(Map<ServerName,List<RegionInfo>> existingAssignments,
RegionInfo region) |
ServerName |
RSGroupBasedLoadBalancer.randomAssignment(RegionInfo region,
List<ServerName> servers) |
| Modifier and Type | Method and Description |
|---|---|
private Map<ServerName,List<RegionInfo>> |
RSGroupBasedLoadBalancer.correctAssignments(Map<ServerName,List<RegionInfo>> existingAssignments) |
private List<ServerName> |
RSGroupBasedLoadBalancer.filterOfflineServers(RSGroupInfo RSGroupInfo,
List<ServerName> onlineServers) |
private List<ServerName> |
RSGroupBasedLoadBalancer.filterServers(Set<Address> servers,
List<ServerName> onlineServers)
Filter servers based on the online servers.
|
private List<ServerName> |
RSGroupInfoManagerImpl.getOnlineRS() |
private Map<TableName,Map<ServerName,List<RegionInfo>>> |
RSGroupAdminServer.getRSGroupAssignmentsByTable(String groupName) |
Map<ServerName,List<RegionInfo>> |
RSGroupBasedLoadBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers) |
Map<ServerName,List<RegionInfo>> |
RSGroupBasedLoadBalancer.roundRobinAssignment(List<RegionInfo> regions,
List<ServerName> servers) |
| Modifier and Type | Method and Description |
|---|---|
void |
RSGroupBasedLoadBalancer.regionOnline(RegionInfo regionInfo,
ServerName sn) |
void |
RSGroupInfoManagerImpl.ServerEventsListenerThread.serverAdded(ServerName serverName) |
void |
RSGroupInfoManagerImpl.FailedOpenUpdaterThread.serverAdded(ServerName serverName) |
void |
RSGroupInfoManagerImpl.ServerEventsListenerThread.serverRemoved(ServerName serverName) |
void |
RSGroupInfoManagerImpl.FailedOpenUpdaterThread.serverRemoved(ServerName serverName) |
| Modifier and Type | Method and Description |
|---|---|
List<RegionPlan> |
RSGroupBasedLoadBalancer.balanceCluster(Map<ServerName,List<RegionInfo>> clusterState) |
List<RegionPlan> |
RSGroupBasedLoadBalancer.balanceCluster(TableName tableName,
Map<ServerName,List<RegionInfo>> clusterState) |
private Map<ServerName,List<RegionInfo>> |
RSGroupBasedLoadBalancer.correctAssignments(Map<ServerName,List<RegionInfo>> existingAssignments) |
private List<ServerName> |
RSGroupBasedLoadBalancer.filterOfflineServers(RSGroupInfo RSGroupInfo,
List<ServerName> onlineServers) |
private List<ServerName> |
RSGroupBasedLoadBalancer.filterServers(Set<Address> servers,
List<ServerName> onlineServers)
Filter servers based on the online servers.
|
private ServerName |
RSGroupBasedLoadBalancer.findServerForRegion(Map<ServerName,List<RegionInfo>> existingAssignments,
RegionInfo region) |
private void |
RSGroupBasedLoadBalancer.generateGroupMaps(List<RegionInfo> regions,
List<ServerName> servers,
org.apache.hbase.thirdparty.com.google.common.collect.ListMultimap<String,RegionInfo> regionMap,
org.apache.hbase.thirdparty.com.google.common.collect.ListMultimap<String,ServerName> serverMap) |
private void |
RSGroupBasedLoadBalancer.generateGroupMaps(List<RegionInfo> regions,
List<ServerName> servers,
org.apache.hbase.thirdparty.com.google.common.collect.ListMultimap<String,RegionInfo> regionMap,
org.apache.hbase.thirdparty.com.google.common.collect.ListMultimap<String,ServerName> serverMap) |
Set<RegionInfo> |
RSGroupBasedLoadBalancer.getMisplacedRegions(Map<RegionInfo,ServerName> regions) |
void |
RSGroupAdminEndpoint.postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ServerName> servers,
List<ServerName> notClearedServers) |
void |
RSGroupAdminEndpoint.postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ServerName> servers,
List<ServerName> notClearedServers) |
ServerName |
RSGroupBasedLoadBalancer.randomAssignment(RegionInfo region,
List<ServerName> servers) |
Map<ServerName,List<RegionInfo>> |
RSGroupBasedLoadBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers) |
Map<ServerName,List<RegionInfo>> |
RSGroupBasedLoadBalancer.retainAssignment(Map<RegionInfo,ServerName> regions,
List<ServerName> servers) |
Map<ServerName,List<RegionInfo>> |
RSGroupBasedLoadBalancer.roundRobinAssignment(List<RegionInfo> regions,
List<ServerName> servers) |
void |
RSGroupBasedLoadBalancer.setClusterLoad(Map<TableName,Map<ServerName,List<RegionInfo>>> clusterLoad) |
| Modifier and Type | Method and Description |
|---|---|
void |
AccessController.preMove(ObserverContext<MasterCoprocessorEnvironment> c,
RegionInfo region,
ServerName srcServer,
ServerName destServer) |
void |
AccessController.preRecommissionRegionServer(ObserverContext<MasterCoprocessorEnvironment> ctx,
ServerName server,
List<byte[]> encodedRegionNames) |
| Modifier and Type | Method and Description |
|---|---|
void |
AccessController.preDecommissionRegionServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ServerName> servers,
boolean offload) |
| Modifier and Type | Field and Description |
|---|---|
private ServerName |
MasterStatusTmpl.ImplData.m_metaLocation |
private ServerName |
MasterStatusTmplImpl.metaLocation |
protected ServerName |
MasterStatusTmpl.metaLocation |
| Modifier and Type | Field and Description |
|---|---|
private Set<ServerName> |
MasterStatusTmplImpl.deadServers |
protected Set<ServerName> |
MasterStatusTmpl.deadServers |
private Set<ServerName> |
MasterStatusTmpl.ImplData.m_deadServers |
private List<ServerName> |
RegionServerListTmpl.ImplData.m_servers |
private List<ServerName> |
MasterStatusTmpl.ImplData.m_servers |
private List<ServerName> |
RegionServerListTmplImpl.servers |
private List<ServerName> |
MasterStatusTmplImpl.servers |
protected List<ServerName> |
RegionServerListTmpl.servers |
protected List<ServerName> |
MasterStatusTmpl.servers |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
MasterStatusTmpl.ImplData.getMetaLocation() |
| Modifier and Type | Method and Description |
|---|---|
Set<ServerName> |
MasterStatusTmpl.ImplData.getDeadServers() |
List<ServerName> |
RegionServerListTmpl.ImplData.getServers() |
List<ServerName> |
MasterStatusTmpl.ImplData.getServers() |
| Modifier and Type | Method and Description |
|---|---|
private void |
RegionServerListTmplImpl.__jamon_innerUnit__baseStats(Writer jamonWriter,
ServerName[] serverNames) |
private void |
RegionServerListTmplImpl.__jamon_innerUnit__compactionStats(Writer jamonWriter,
ServerName[] serverNames) |
private void |
RegionServerListTmplImpl.__jamon_innerUnit__emptyStat(Writer jamonWriter,
ServerName serverName) |
private void |
RegionServerListTmplImpl.__jamon_innerUnit__memoryStats(Writer jamonWriter,
ServerName[] serverNames) |
private void |
RegionServerListTmplImpl.__jamon_innerUnit__requestStats(Writer jamonWriter,
ServerName[] serverNames) |
private void |
RegionServerListTmplImpl.__jamon_innerUnit__serverNameLink(Writer jamonWriter,
ServerName serverName,
ServerMetrics serverLoad) |
private void |
RegionServerListTmplImpl.__jamon_innerUnit__storeStats(Writer jamonWriter,
ServerName[] serverNames) |
MasterStatusTmpl |
MasterStatusTmpl.setMetaLocation(ServerName p_metaLocation) |
void |
MasterStatusTmpl.ImplData.setMetaLocation(ServerName metaLocation) |
| Modifier and Type | Method and Description |
|---|---|
MasterStatusTmpl |
MasterStatusTmpl.setDeadServers(Set<ServerName> p_deadServers) |
void |
MasterStatusTmpl.ImplData.setDeadServers(Set<ServerName> deadServers) |
RegionServerListTmpl |
RegionServerListTmpl.setServers(List<ServerName> p_servers) |
void |
RegionServerListTmpl.ImplData.setServers(List<ServerName> servers) |
MasterStatusTmpl |
MasterStatusTmpl.setServers(List<ServerName> p_servers) |
void |
MasterStatusTmpl.ImplData.setServers(List<ServerName> servers) |
| Modifier and Type | Field and Description |
|---|---|
private ServerName |
Canary.RegionTask.serverName |
| Modifier and Type | Method and Description |
|---|---|
void |
Canary.RegionStdOutSink.publishReadFailure(ServerName serverName,
RegionInfo region,
ColumnFamilyDescriptor column,
Exception e) |
void |
Canary.RegionStdOutSink.publishReadFailure(ServerName serverName,
RegionInfo region,
Exception e) |
void |
Canary.RegionStdOutSink.publishReadTiming(ServerName serverName,
RegionInfo region,
ColumnFamilyDescriptor column,
long msTime) |
void |
Canary.RegionStdOutSink.publishWriteFailure(ServerName serverName,
RegionInfo region,
ColumnFamilyDescriptor column,
Exception e) |
void |
Canary.RegionStdOutSink.publishWriteFailure(ServerName serverName,
RegionInfo region,
Exception e) |
void |
Canary.RegionStdOutSink.publishWriteTiming(ServerName serverName,
RegionInfo region,
ColumnFamilyDescriptor column,
long msTime) |
| Constructor and Description |
|---|
RegionTask(Connection connection,
RegionInfo region,
ServerName serverName,
Canary.RegionStdOutSink sink,
Canary.RegionTask.TaskType taskType,
boolean rawScanEnabled,
LongAdder rwLatency) |
| Modifier and Type | Field and Description |
|---|---|
(package private) ServerName |
HbckRegionInfo.MetaEntry.regionServer |
private ServerName |
HBaseFsck.WorkItemRegion.rsinfo |
private ServerName |
HbckRegionInfo.OnlineEntry.serverName |
private ServerName |
RegionMover.MoveWithAck.sourceServer |
private ServerName |
RegionMover.MoveWithoutAck.sourceServer |
private ServerName |
RegionMover.MoveWithAck.targetServer |
private ServerName |
RegionMover.MoveWithoutAck.targetServer |
| Modifier and Type | Field and Description |
|---|---|
(package private) TreeSet<ServerName> |
HbckTableInfo.deployedOn |
private List<ServerName> |
HbckRegionInfo.deployedOn |
| Modifier and Type | Method and Description |
|---|---|
private ServerName |
HBaseFsck.getMetaRegionServerName(int replicaId) |
ServerName |
HbckRegionInfo.MetaEntry.getRegionServer() |
ServerName |
HbckRegionInfo.OnlineEntry.getServerName() |
private ServerName |
RegionMover.getServerNameForRegion(RegionInfo region)
Get servername that is up in hbase:meta hosting the given region.
|
private ServerName |
RegionMover.getTargetServer() |
private ServerName |
RegionMover.stripServer(List<ServerName> regionServers,
String hostname,
int port)
Remove the servername whose hostname and port portion matches from the passed array of servers.
|
| Modifier and Type | Method and Description |
|---|---|
List<ServerName> |
HbckRegionInfo.getDeployedOn() |
| Modifier and Type | Method and Description |
|---|---|
void |
HbckRegionInfo.addServer(RegionInfo regionInfo,
ServerName serverName) |
void |
HbckTableInfo.addServer(ServerName server) |
static void |
HBaseFsckRepair.closeRegionSilentlyAndWait(Connection connection,
ServerName server,
RegionInfo region)
Contacts a region server and waits up to hbase.hbck.close.timeout ms
(default 120s) to close the region.
|
private boolean |
RegionMover.isSameServer(RegionInfo region,
ServerName serverName)
Returns true if passed region is still on serverName when we look at hbase:meta.
|
private void |
RegionMover.unloadRegions(ServerName server,
List<ServerName> regionServers,
List<RegionInfo> movedRegions) |
| Modifier and Type | Method and Description |
|---|---|
static void |
HBaseFsckRepair.fixMetaHoleOnlineAndAddReplicas(org.apache.hadoop.conf.Configuration conf,
RegionInfo hri,
Collection<ServerName> servers,
int numReplicas)
Puts the specified RegionInfo into META with replica related columns
|
static void |
HBaseFsckRepair.fixMultiAssignment(Connection connection,
RegionInfo region,
List<ServerName> servers)
Fix multiple assignment by doing silent closes on each RS hosting the region
and then force ZK unassigned node to OFFLINE to trigger assignment by
master.
|
(package private) void |
HBaseFsck.processRegionServers(Collection<ServerName> regionServerList)
Contacts each regionserver and fetches metadata about regions.
|
private void |
RegionMover.stripExcludes(List<ServerName> regionServers)
Excludes the servername whose hostname and port portion matches the list given in exclude file
|
private void |
RegionMover.stripMaster(List<ServerName> regionServers)
Exclude master from list of RSs to move regions to
|
private ServerName |
RegionMover.stripServer(List<ServerName> regionServers,
String hostname,
int port)
Remove the servername whose hostname and port portion matches from the passed array of servers.
|
private void |
RegionMover.unloadRegions(ServerName server,
List<ServerName> regionServers,
List<RegionInfo> movedRegions) |
| Constructor and Description |
|---|
MetaEntry(RegionInfo rinfo,
ServerName regionServer,
long modTime) |
MetaEntry(RegionInfo rinfo,
ServerName regionServer,
long modTime,
RegionInfo splitA,
RegionInfo splitB) |
MoveWithAck(RegionInfo regionInfo,
ServerName sourceServer,
ServerName targetServer,
List<RegionInfo> movedRegions) |
MoveWithoutAck(RegionInfo regionInfo,
ServerName sourceServer,
ServerName targetServer,
List<RegionInfo> movedRegions) |
OnlineEntry(RegionInfo regionInfo,
ServerName serverName) |
WorkItemRegion(HBaseFsck hbck,
ServerName info,
HbckErrorReporter errors,
ClusterConnection connection) |
| Modifier and Type | Field and Description |
|---|---|
private ServerName |
MajorCompactor.Compact.serverName |
| Modifier and Type | Field and Description |
|---|---|
private Set<ServerName> |
ClusterCompactionQueues.compactingServers |
private Map<ServerName,List<MajorCompactionRequest>> |
ClusterCompactionQueues.compactionQueues |
| Modifier and Type | Method and Description |
|---|---|
(package private) Optional<ServerName> |
ClusterCompactionQueues.getLargestQueueFromServersNotCompacting() |
| Modifier and Type | Method and Description |
|---|---|
(package private) void |
ClusterCompactionQueues.addToCompactionQueue(ServerName serverName,
MajorCompactionRequest info) |
(package private) List<MajorCompactionRequest> |
ClusterCompactionQueues.getQueue(ServerName serverName) |
(package private) void |
ClusterCompactionQueues.releaseCompaction(ServerName serverName) |
(package private) MajorCompactionRequest |
ClusterCompactionQueues.reserveForCompaction(ServerName serverName) |
| Constructor and Description |
|---|
Compact(ServerName serverName,
MajorCompactionRequest request) |
| Modifier and Type | Method and Description |
|---|---|
static ServerName |
AbstractFSWALProvider.getServerNameFromWALDirectoryName(org.apache.hadoop.conf.Configuration conf,
String path)
Pulls a ServerName out of a Path generated according to our layout rules.
|
static ServerName |
AbstractFSWALProvider.getServerNameFromWALDirectoryName(org.apache.hadoop.fs.Path logFile)
This function returns region server name from a log file name which is in one of the following
formats:
hdfs://<name node>/hbase/.logs/<server name>-splitting/...
hdfs://<name node>/hbase/.logs/<server name>/...
|
| Modifier and Type | Method and Description |
|---|---|
ServerName |
MetaTableLocator.blockUntilAvailable(ZKWatcher zkw,
int replicaId,
long timeout)
Wait until the meta region is available and is not in transition.
|
ServerName |
MetaTableLocator.blockUntilAvailable(ZKWatcher zkw,
long timeout)
Wait until the meta region is available and is not in transition.
|
ServerName |
MasterAddressTracker.getMasterAddress()
Get the address of the current master if one is available.
|
ServerName |
MasterAddressTracker.getMasterAddress(boolean refresh)
Get the address of the current master if one is available.
|
static ServerName |
MasterAddressTracker.getMasterAddress(ZKWatcher zkw)
Get master address.
|
ServerName |
MetaTableLocator.getMetaRegionLocation(ZKWatcher zkw)
Gets the meta region location, if available.
|
ServerName |
MetaTableLocator.getMetaRegionLocation(ZKWatcher zkw,
int replicaId)
Gets the meta region location, if available.
|
static ServerName[] |
ZKServerTool.readZKNodes(org.apache.hadoop.conf.Configuration conf) |
ServerName |
MetaTableLocator.waitMetaRegionLocation(ZKWatcher zkw,
int replicaId,
long timeout)
Gets the meta region location, if available, and waits for up to the specified timeout if not
immediately available.
|
ServerName |
MetaTableLocator.waitMetaRegionLocation(ZKWatcher zkw,
long timeout)
Gets the meta region location, if available, and waits for up to the
specified timeout if not immediately available.
|
| Modifier and Type | Method and Description |
|---|---|
List<ServerName> |
MetaTableLocator.blockUntilAvailable(ZKWatcher zkw,
long timeout,
org.apache.hadoop.conf.Configuration conf)
Wait until the primary meta region is available.
|
List<Pair<RegionInfo,ServerName>> |
MetaTableLocator.getMetaRegionsAndLocations(ZKWatcher zkw) |
List<Pair<RegionInfo,ServerName>> |
MetaTableLocator.getMetaRegionsAndLocations(ZKWatcher zkw,
int replicaId)
Gets the meta regions and their locations for the given path and replica ID.
|
| Modifier and Type | Method and Description |
|---|---|
int |
MasterAddressTracker.getBackupMasterInfoPort(ServerName sn)
Get the info port of the backup master if it is available.
|
private static org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface |
MetaTableLocator.getCachedConnection(ClusterConnection connection,
ServerName sn) |
static boolean |
MasterAddressTracker.setMasterAddress(ZKWatcher zkw,
String znode,
ServerName master,
int infoPort)
Set master address into the
master znode or into the backup
subdirectory of backup masters; switch off the passed in znode
path. |
static void |
MetaTableLocator.setMetaLocation(ZKWatcher zookeeper,
ServerName serverName,
int replicaId,
RegionState.State state)
Sets the location of
hbase:meta in ZooKeeper to the specified server address. |
static void |
MetaTableLocator.setMetaLocation(ZKWatcher zookeeper,
ServerName serverName,
RegionState.State state)
Sets the location of
hbase:meta in ZooKeeper to the
specified server address. |
(package private) static byte[] |
MasterAddressTracker.toByteArray(ServerName sn,
int infoPort) |
private boolean |
MetaTableLocator.verifyRegionLocation(ClusterConnection connection,
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface hostingServer,
ServerName address,
byte[] regionName)
Verify we can connect to
hostingServer and that its carrying
regionName. |
| Modifier and Type | Method and Description |
|---|---|
private List<RegionInfo> |
MetaTableLocator.getListOfRegionInfos(List<Pair<RegionInfo,ServerName>> pairs) |
Copyright © 2007–2019 The Apache Software Foundation. All rights reserved.