| Modifier and Type | Field and Description |
|---|---|
static List<ServerName> |
ServerName.EMPTY_SERVER_LIST |
| 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 |
SplitLogTask.getServerName() |
ServerName |
Server.getServerName() |
ServerName |
ServerLoad.getServerName()
Deprecated.
|
ServerName |
ServerMetrics.getServerName() |
ServerName |
HRegionLocation.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> |
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() |
Map<ServerName,ServerMetrics> |
ClusterStatus.getLiveServerMetrics()
Deprecated.
|
Map<ServerName,ServerMetrics> |
ClusterMetrics.getLiveServerMetrics() |
static Pair<RegionInfo,ServerName> |
MetaTableAccessor.getRegion(Connection connection,
byte[] regionName)
Deprecated.
|
Collection<ServerName> |
ClusterStatus.getServers()
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0
Use
ClusterStatus.getLiveServerMetrics() instead. |
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 regionA,
long regionAOpenSeqNum,
RegionInfo regionB,
long regionBOpenSeqNum,
ServerName sn,
int regionReplication)
Merge the two 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,
String version) |
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,
long parentOpenSeqNum,
RegionInfo splitA,
RegionInfo splitB,
ServerName sn,
int regionReplication)
Splits the region into two in an atomic operation.
|
static ServerMetrics |
ServerMetricsBuilder.toServerMetrics(ServerName serverName,
ClusterStatusProtos.ServerLoad serverLoadPB) |
static ServerMetrics |
ServerMetricsBuilder.toServerMetrics(ServerName serverName,
int versionNumber,
String version,
ClusterStatusProtos.ServerLoad serverLoadPB) |
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 |
|---|---|
ClusterMetricsBuilder |
ClusterMetricsBuilder.setBackerMasterNames(List<ServerName> value) |
ClusterMetricsBuilder |
ClusterMetricsBuilder.setDeadServerNames(List<ServerName> value) |
ClusterMetricsBuilder |
ClusterMetricsBuilder.setLiveServerMetrics(Map<ServerName,ServerMetrics> value) |
| Constructor and Description |
|---|
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,
ClusterStatusProtos.ServerLoad serverLoad)
Deprecated.
|
Unassigned(ServerName originServer) |
| Constructor and Description |
|---|
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 |
|---|---|
protected ConcurrentHashMap<ServerName,ConcurrentMap<byte[],MetricsConnection.RegionStats>> |
MetricsConnection.serverStats |
| Modifier and Type | Method and Description |
|---|---|
default ServerName |
Admin.getMaster() |
| Modifier and Type | Method and Description |
|---|---|
List<ServerName> |
HBaseAdmin.clearDeadServers(List<ServerName> servers) |
CompletableFuture<List<ServerName>> |
AsyncAdmin.clearDeadServers(List<ServerName> servers)
Clear dead region servers from master.
|
List<ServerName> |
Admin.clearDeadServers(List<ServerName> servers)
Clear dead region servers from master.
|
default CompletableFuture<Collection<ServerName>> |
AsyncAdmin.getBackupMasters() |
default Collection<ServerName> |
Admin.getBackupMasters() |
default CompletableFuture<ServerName> |
AsyncAdmin.getMaster() |
default CompletableFuture<Collection<ServerName>> |
AsyncAdmin.getRegionServers() |
default Collection<ServerName> |
Admin.getRegionServers() |
default CompletableFuture<List<ServerName>> |
AsyncAdmin.listDeadServers()
List all the dead region servers.
|
default List<ServerName> |
Admin.listDeadServers()
List dead region servers.
|
List<ServerName> |
HBaseAdmin.listDecommissionedRegionServers() |
CompletableFuture<List<ServerName>> |
AsyncAdmin.listDecommissionedRegionServers()
List region servers marked as decommissioned, which can not be assigned regions.
|
List<ServerName> |
Admin.listDecommissionedRegionServers()
List region servers marked as decommissioned, which can not be assigned regions.
|
| Modifier and Type | Method and Description |
|---|---|
void |
MetaCache.cacheLocation(TableName tableName,
ServerName source,
HRegionLocation location)
Put a newly discovered HRegionLocation into the cache.
|
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 |
HBaseAdmin.clearCompactionQueues(ServerName sn,
Set<String> queues) |
CompletableFuture<Void> |
AsyncAdmin.clearCompactionQueues(ServerName serverName,
Set<String> queues)
Clear compacting queues on a region server.
|
void |
Admin.clearCompactionQueues(ServerName serverName,
Set<String> queues)
Clear compacting queues on a regionserver.
|
void |
HBaseAdmin.closeRegion(ServerName unused,
HRegionInfo hri)
Deprecated.
|
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.compactRegionServer(ServerName serverName) |
CompletableFuture<Void> |
AsyncAdmin.compactRegionServer(ServerName serverName)
Compact all regions on the region server.
|
void |
Admin.compactRegionServer(ServerName serverName)
Compact all regions on the region server.
|
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). |
<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.
|
CoprocessorRpcChannel |
HBaseAdmin.coprocessorService(ServerName serverName) |
CoprocessorRpcChannel |
Admin.coprocessorService(ServerName serverName)
Creates and returns a
RpcChannel instance
connected to the passed region server. |
static ClusterConnection |
ConnectionUtils.createShortCircuitConnection(org.apache.hadoop.conf.Configuration conf,
ExecutorService pool,
User user,
ServerName serverName,
AdminProtos.AdminService.BlockingInterface admin,
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.
|
void |
RequestController.decTaskCounters(Collection<byte[]> regions,
ServerName sn)
Decrement the counter if a task is accomplished.
|
void |
HBaseAdmin.flushRegionServer(ServerName serverName) |
CompletableFuture<Void> |
AsyncAdmin.flushRegionServer(ServerName serverName)
Flush all region on the region server.
|
void |
Admin.flushRegionServer(ServerName serverName)
Flush all regions on the region server.
|
AdminProtos.AdminService.BlockingInterface |
ClusterConnection.getAdmin(ServerName serverName)
Establishes a connection to the region server at the specified address.
|
AdminProtos.AdminService.BlockingInterface |
ConnectionUtils.ShortCircuitingClusterConnection.getAdmin(ServerName sn) |
ClientProtos.ClientService.BlockingInterface |
ClusterConnection.getClient(ServerName serverName)
Establishes a connection to the region server at the specified address, and returns
a region client protocol.
|
ClientProtos.ClientService.BlockingInterface |
ConnectionUtils.ShortCircuitingClusterConnection.getClient(ServerName sn) |
Hbck |
AsyncConnection.getHbck(ServerName masterServer)
Retrieve an Hbck implementation to fix an HBase cluster.
|
Hbck |
ClusterConnection.getHbck(ServerName masterServer)
Retrieve an Hbck implementation to fix an HBase cluster.
|
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). |
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). |
CompletableFuture<List<RegionMetrics>> |
AsyncAdmin.getRegionMetrics(ServerName serverName)
Get a list of
RegionMetrics of all regions hosted on a region seerver. |
default List<RegionMetrics> |
Admin.getRegionMetrics(ServerName serverName)
Get
RegionMetrics of all regions hosted on a regionserver. |
List<RegionMetrics> |
HBaseAdmin.getRegionMetrics(ServerName serverName,
TableName tableName) |
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. |
List<RegionMetrics> |
Admin.getRegionMetrics(ServerName serverName,
TableName tableName)
Get
RegionMetrics of all regions hosted on a regionserver for a table. |
List<RegionInfo> |
HBaseAdmin.getRegions(ServerName sn) |
CompletableFuture<List<RegionInfo>> |
AsyncAdmin.getRegions(ServerName serverName)
Get all the online regions on a region server.
|
List<RegionInfo> |
Admin.getRegions(ServerName serverName)
Get all the online regions on a region server.
|
static QuotaProtos.GetSpaceQuotaSnapshotsResponse |
QuotaStatusCalls.getRegionServerQuotaSnapshot(ClusterConnection clusterConn,
int timeout,
ServerName sn)
|
static 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. |
ServerStatistics |
ServerStatisticTracker.getStats(ServerName server) |
void |
RequestController.incTaskCounters(Collection<byte[]> regions,
ServerName sn)
Increment the counter if we build a valid task.
|
void |
HBaseAdmin.majorCompactRegionServer(ServerName serverName) |
CompletableFuture<Void> |
AsyncAdmin.majorCompactRegionServer(ServerName serverName)
Compact all regions on the region server.
|
void |
Admin.majorCompactRegionServer(ServerName serverName)
Major compact all regions on the region server.
|
CompletableFuture<Void> |
AsyncAdmin.move(byte[] regionName,
ServerName destServerName)
Move the region
r to dest. |
void |
HBaseAdmin.recommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames) |
CompletableFuture<Void> |
AsyncAdmin.recommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames)
Remove decommission marker from a region server to allow regions assignments.
|
void |
Admin.recommissionRegionServer(ServerName server,
List<byte[]> encodedRegionNames)
Remove decommission marker from a region server to allow regions assignments.
|
void |
HBaseAdmin.rollWALWriter(ServerName serverName) |
CompletableFuture<Void> |
AsyncAdmin.rollWALWriter(ServerName serverName)
Roll the log writer.
|
void |
Admin.rollWALWriter(ServerName serverName)
Roll the log writer.
|
protected abstract void |
RegionServerCallable.setStubByServiceName(ServerName serviceName)
Set the RCP client stub
|
protected void |
ClientServiceCallable.setStubByServiceName(ServerName serviceName) |
CompletableFuture<Void> |
AsyncAdmin.stopRegionServer(ServerName serverName)
Stop the designated regionserver.
|
void |
ClusterConnection.updateCachedLocations(TableName tableName,
byte[] regionName,
byte[] rowkey,
Object exception,
ServerName source)
Update the location cache.
|
void |
HBaseAdmin.updateConfiguration(ServerName server) |
CompletableFuture<Void> |
AsyncAdmin.updateConfiguration(ServerName serverName)
Update the configuration and trigger an online config change on the regionserver.
|
void |
Admin.updateConfiguration(ServerName server)
Update the configuration and trigger an online config change
on the regionserver.
|
void |
ServerStatisticTracker.updateRegionStats(ServerName server,
byte[] region,
RegionLoadStats currentStats) |
void |
StatisticTrackable.updateRegionStats(ServerName server,
byte[] region,
RegionLoadStats stats)
Update stats per region.
|
void |
MetricsConnection.updateRegionStats(ServerName serverName,
byte[] regionName,
RegionLoadStats stats) |
void |
MetricsConnection.updateServerStats(ServerName serverName,
byte[] regionName,
Object r) |
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 |
|---|---|
List<ServerName> |
HBaseAdmin.clearDeadServers(List<ServerName> servers) |
CompletableFuture<List<ServerName>> |
AsyncAdmin.clearDeadServers(List<ServerName> servers)
Clear dead region servers from master.
|
List<ServerName> |
Admin.clearDeadServers(List<ServerName> servers)
Clear dead region servers from master.
|
void |
HBaseAdmin.decommissionRegionServers(List<ServerName> servers,
boolean offload) |
CompletableFuture<Void> |
AsyncAdmin.decommissionRegionServers(List<ServerName> servers,
boolean offload)
Mark region server(s) as decommissioned to prevent additional regions from getting
assigned to them.
|
void |
Admin.decommissionRegionServers(List<ServerName> servers,
boolean offload)
Mark region server(s) as decommissioned to prevent additional regions from getting
assigned to them.
|
| Constructor and Description |
|---|
AsyncAdminRequestRetryingCaller(org.apache.hbase.thirdparty.io.netty.util.Timer retryTimer,
org.apache.hadoop.hbase.client.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,
org.apache.hadoop.hbase.client.AsyncConnectionImpl conn,
long pauseNs,
int maxAttempts,
long operationTimeoutNs,
long rpcTimeoutNs,
int startLogErrorsCnt,
ServerName serverName,
AsyncServerRequestRpcRetryingCaller.Callable<T> callable) |
| 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 | 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.
|
| Constructor and Description |
|---|
ZkSplitLogWorkerCoordination(ServerName serverName,
ZKWatcher watcher) |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
RegionServerCoprocessorEnvironment.getServerName() |
ServerName |
RegionCoprocessorEnvironment.getServerName() |
ServerName |
MasterCoprocessorEnvironment.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 | Method and Description |
|---|---|
ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNode(List<ServerName> favoredNodes) |
ServerName |
FavoredNodeAssignmentHelper.generateMissingFavoredNode(List<ServerName> favoredNodes,
List<ServerName> excludeNodes) |
static ServerName[] |
FavoredNodeAssignmentHelper.getFavoredNodesList(byte[] favoredNodes) |
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) |
ServerName |
FavoredNodeLoadBalancer.randomAssignment(RegionInfo regionInfo,
List<ServerName> servers) |
| Modifier and Type | Method and Description |
|---|---|
static FavoredNodesPlan.Position |
FavoredNodesPlan.getFavoredServerPosition(List<ServerName> favoredNodes,
ServerName server)
Return the position of the server in the favoredNodes list.
|
Set<RegionInfo> |
FavoredNodesManager.getRegionsOfFavoredNode(ServerName serverName) |
ServerName[] |
FavoredNodeAssignmentHelper.getSecondaryAndTertiary(RegionInfo regionInfo,
ServerName primaryRS) |
| Modifier and Type | Method and Description |
|---|---|
List<RegionPlan> |
FavoredNodeLoadBalancer.balanceCluster(Map<ServerName,List<RegionInfo>> clusterState) |
List<RegionPlan> |
FavoredNodeLoadBalancer.balanceCluster(TableName tableName,
Map<ServerName,List<RegionInfo>> clusterState) |
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) |
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.
|
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) |
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) |
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 |
AbstractRpcClient.cancelConnections(ServerName sn)
Interrupt the connections to the given ip:port server.
|
void |
RpcClient.cancelConnections(ServerName sn)
Interrupt the connections to the given server.
|
org.apache.hbase.thirdparty.com.google.protobuf.BlockingRpcChannel |
AbstractRpcClient.createBlockingRpcChannel(ServerName sn,
User ticket,
int rpcTimeout) |
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.RpcChannel |
AbstractRpcClient.createRpcChannel(ServerName sn,
User user,
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.
|
| Modifier and Type | Field and Description |
|---|---|
static ServerName |
LoadBalancer.BOGUS_SERVER_NAME |
ServerName |
SplitLogManager.Task.cur_worker_name |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
RegionPlan.getDestination()
Get the destination server for the plan for this region.
|
ServerName |
HMaster.getServerName() |
ServerName |
RegionState.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
|
| 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.
|
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) |
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<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
|
HashMap<String,List<Pair<ServerName,ReplicationLoadSource>>> |
HMaster.getReplicationLoad(ServerName[] serverNames) |
Map<ServerName,List<RegionInfo>> |
SnapshotOfRegionAssignmentFromMeta.getSecondaryToRegionInfoMap() |
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<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.
|
void |
DeadServer.add(ServerName sn,
boolean processing)
Adds the server to the dead server list if it's not there already.
|
boolean |
ServerManager.addServerToDrainList(ServerName sn)
Add the server to the drain list.
|
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.
|
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.
|
boolean |
ServerManager.expireServer(ServerName serverName)
Expire the passed server.
|
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) |
HashMap<String,List<Pair<ServerName,ReplicationLoadSource>>> |
HMaster.getReplicationLoad(ServerName[] serverNames) |
AdminProtos.AdminService.BlockingInterface |
ServerManager.getRsAdmin(ServerName sn) |
Date |
DeadServer.getTimeOfDeath(ServerName deadServerName)
Get the time when a server died
|
String |
ServerManager.getVersion(ServerName serverName)
May return "0.0.0" when server is not online
|
int |
ServerManager.getVersionNumber(ServerName serverName)
May return 0 when server is not online.
|
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) |
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.
|
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) |
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.
|
void |
MasterWalManager.splitLog(ServerName serverName) |
void |
MasterWalManager.splitMetaLog(ServerName serverName)
Specialized method to handle the splitting for meta WAL
|
| 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
|
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.
|
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 |
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) |
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<ServerCrashProcedure> deadServersFromPE,
Set<ServerName> liveServersFromWALDir,
Set<ServerName> splittingServersFromWALDir)
Starts the tracking of online RegionServers.
|
void |
RegionServerTracker.start(Set<ServerCrashProcedure> deadServersFromPE,
Set<ServerName> liveServersFromWALDir,
Set<ServerName> splittingServersFromWALDir)
Starts the tracking of online RegionServers.
|
| Constructor and Description |
|---|
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.
|
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 | Method and Description |
|---|---|
ServerName |
RegionStates.RegionStateNode.getLastHost() |
ServerName |
RegionStates.RegionStateNode.getRegionLocation() |
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() |
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,List<RegionInfo>> |
AssignmentManager.getSnapShotOfAssignment(Collection<RegionInfo> regions) |
Map<ServerName,List<RegionInfo>> |
RegionStates.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) |
AssignProcedure |
AssignmentManager.createAssignProcedure(RegionInfo regionInfo,
ServerName targetServer) |
AssignProcedure |
AssignmentManager.createAssignProcedure(RegionInfo regionInfo,
ServerName targetServer,
boolean override) |
RegionStates.ServerStateNode |
RegionStates.getServerNode(ServerName serverName) |
List<RegionInfo> |
RegionStates.getServerRegionInfoSet(ServerName serverName)
Returns the set of regions hosted by the specified server
|
boolean |
AssignmentManager.isCarryingMeta(ServerName serverName) |
protected boolean |
RegionTransitionProcedure.isServerOnline(MasterProcedureEnv env,
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 mother,
RegionInfo father)
When called here, the merge has happened.
|
void |
AssignmentManager.markRegionAsSplit(RegionInfo parent,
ServerName serverName,
RegionInfo daughterA,
RegionInfo daughterB) |
void |
RegionStateStore.mergeRegions(RegionInfo child,
RegionInfo hriA,
RegionInfo hriB,
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) |
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,
RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
long seqId) |
void |
AssignmentManager.serverAdded(ServerName serverName) |
void |
AssignmentManager.serverRemoved(ServerName serverName) |
void |
RegionStates.RegionStateNode.setLastHost(ServerName serverName) |
ServerName |
RegionStates.RegionStateNode.setRegionLocation(ServerName serverName) |
void |
RegionStateStore.splitRegion(RegionInfo parent,
RegionInfo hriA,
RegionInfo hriB,
ServerName serverName) |
long |
AssignmentManager.submitServerCrash(ServerName serverName,
boolean shouldSplitWal) |
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 |
|---|---|
AssignProcedure[] |
AssignmentManager.createRoundRobinAssignProcedures(List<RegionInfo> hris,
List<ServerName> serversToExclude)
Create round-robin assigns.
|
| Constructor and Description |
|---|
AssignProcedure(RegionInfo regionInfo,
ServerName destinationServer) |
AssignProcedure(RegionInfo regionInfo,
ServerName destinationServer,
boolean override) |
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 |
| Modifier and Type | Method and Description |
|---|---|
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.
|
List<ServerName> |
FavoredStochasticBalancer.getFavoredNodes(RegionInfo regionInfo) |
protected Map<ServerName,List<RegionInfo>> |
BaseLoadBalancer.getRegionAssignmentsByServer(Collection<RegionInfo> regions) |
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) |
| Modifier and Type | Method and Description |
|---|---|
void |
BaseLoadBalancer.regionOnline(RegionInfo regionInfo,
ServerName sn) |
| 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.
|
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> |
StochasticLoadBalancer.balanceCluster(Map<ServerName,List<RegionInfo>> clusterState)
Given the cluster state this will try and approach an optimal balance.
|
List<RegionPlan> |
FavoredStochasticBalancer.balanceCluster(Map<ServerName,List<RegionInfo>> clusterState) |
List<RegionPlan> |
SimpleLoadBalancer.balanceCluster(TableName tableName,
Map<ServerName,List<RegionInfo>> clusterState) |
List<RegionPlan> |
StochasticLoadBalancer.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,org.apache.hadoop.hbase.master.balancer.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,
boolean hasRegionReplica) |
void |
FavoredStochasticBalancer.generateFavoredNodesForDaughter(List<ServerName> servers,
RegionInfo parent,
RegionInfo regionA,
RegionInfo regionB) |
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) |
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) |
void |
SimpleLoadBalancer.setClusterLoad(Map<TableName,Map<ServerName,List<RegionInfo>>> clusterLoad) |
void |
BaseLoadBalancer.setClusterLoad(Map<TableName,Map<ServerName,List<RegionInfo>>> clusterLoad) |
| Constructor and Description |
|---|
Cluster(Collection<RegionInfo> unassignedRegions,
Map<ServerName,List<RegionInfo>> clusterState,
Map<String,Deque<org.apache.hadoop.hbase.master.balancer.BalancerRegionLoad>> loads,
org.apache.hadoop.hbase.master.balancer.RegionLocationFinder regionFinder,
RackManager rackManager) |
Cluster(Map<ServerName,List<RegionInfo>> clusterState,
Map<String,Deque<org.apache.hadoop.hbase.master.balancer.BalancerRegionLoad>> loads,
org.apache.hadoop.hbase.master.balancer.RegionLocationFinder regionFinder,
RackManager rackManager) |
ClusterLoadState(Map<ServerName,List<RegionInfo>> clusterState) |
| Modifier and Type | Field and Description |
|---|---|
protected ServerName |
ServerRemoteProcedure.targetServer |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
RSProcedureDispatcher.RegionCloseOperation.getDestinationServer() |
protected ServerName |
RSProcedureDispatcher.AbstractRSRemoteCall.getServerName() |
ServerName |
ServerCrashProcedure.getServerName() |
ServerName |
ServerProcedureInterface.getServerName() |
| Modifier and Type | Method and Description |
|---|---|
protected void |
RSProcedureDispatcher.abortPendingOperations(ServerName serverName,
Set<RemoteProcedureDispatcher.RemoteProcedure> operations) |
AdminProtos.CloseRegionRequest |
RSProcedureDispatcher.RegionCloseOperation.buildCloseRegionRequest(ServerName serverName) |
protected static AdminProtos.OpenRegionRequest |
RSProcedureDispatcher.buildOpenRegionRequest(MasterProcedureEnv env,
ServerName serverName,
List<RSProcedureDispatcher.RegionOpenOperation> operations) |
boolean |
ServerRemoteProcedure.remoteCallFailed(MasterProcedureEnv env,
ServerName serverName,
IOException exception) |
protected void |
RSProcedureDispatcher.remoteDispatch(ServerName serverName,
Set<RemoteProcedureDispatcher.RemoteProcedure> remoteProcedures) |
protected AdminProtos.ExecuteProceduresResponse |
RSProcedureDispatcher.ExecuteProceduresRemoteCall.sendRequest(ServerName serverName,
AdminProtos.ExecuteProceduresRequest request) |
void |
RSProcedureDispatcher.serverAdded(ServerName serverName) |
void |
RSProcedureDispatcher.serverRemoved(ServerName serverName) |
void |
RSProcedureDispatcher.splitAndResolveOperation(ServerName serverName,
Set<RemoteProcedureDispatcher.RemoteProcedure> operations,
org.apache.hadoop.hbase.master.procedure.RSProcedureDispatcher.RemoteProcedureResolver resolver)
Fetches
RemoteProcedureDispatcher.RemoteOperations
from the given remoteProcedures and groups them by class of the returned operation. |
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) |
ExecuteProceduresRemoteCall(ServerName serverName,
Set<RemoteProcedureDispatcher.RemoteProcedure> remoteProcedures) |
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.
|
| Constructor and Description |
|---|
RegionOpenOperation(RemoteProcedureDispatcher.RemoteProcedure remoteProcedure,
RegionInfo regionInfo,
List<ServerName> favoredNodes,
boolean openForReplay) |
| Modifier and Type | Method and Description |
|---|---|
RemoteProcedureDispatcher.RemoteOperation |
RefreshPeerProcedure.remoteCallBuild(MasterProcedureEnv env,
ServerName remote) |
| Constructor and Description |
|---|
RefreshPeerProcedure(String peerId,
PeerProcedureInterface.PeerOperationType type,
ServerName targetServer) |
| 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 ServerName |
ProtobufUtil.toServerName(byte[] data)
Get a ServerName from the passed in data bytes.
|
static ServerName |
ProtobufUtil.toServerName(HBaseProtos.ServerName proto)
Convert a protocol buffer ServerName to a ServerName
|
| Modifier and Type | Method and Description |
|---|---|
static HBaseProtos.ServerName |
ProtobufUtil.toServerName(ServerName serverName)
Convert a ServerName to a protocol buffer ServerName
|
| 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.
|
| 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 |
HRegionServer.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 |
|---|
ScannerIdGenerator(ServerName 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 | 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> |
ReplicationQueueStorage.getListOfReplicators()
Get a list of all region servers that have outstanding replication queues.
|
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 |
|---|---|
void |
ReplicationQueueStorage.addWAL(ServerName serverName,
String queueId,
String fileName)
Add a new WAL file to the given queue for a given regionserver.
|
Pair<String,SortedSet<String>> |
ReplicationQueueStorage.claimQueue(ServerName sourceServerName,
String queueId,
ServerName destServerName)
Change ownership for the queue identified by queueId and belongs to a dead region server.
|
List<String> |
ReplicationQueueStorage.getAllQueues(ServerName serverName)
Get a list of all queues for the specified region server.
|
String |
ReplicationQueueStorage.getRsNode(ServerName serverName)
Get full znode name for given region server
|
long |
ReplicationQueueStorage.getWALPosition(ServerName serverName,
String queueId,
String fileName)
Get the current position for a specific WAL in a given queue for a given regionserver.
|
List<String> |
ReplicationQueueStorage.getWALsInQueue(ServerName serverName,
String queueId)
Get a list of all WALs in the given queue on the given region server.
|
void |
ReplicationQueueStorage.removeQueue(ServerName serverName,
String queueId)
Remove a replication queue for a given regionserver.
|
void |
ReplicationQueueStorage.removeReplicatorIfQueueIsEmpty(ServerName serverName)
Remove the record of region server if the queue is empty.
|
void |
ReplicationQueueStorage.removeWAL(ServerName serverName,
String queueId,
String fileName)
Remove an WAL file from the given queue for a given regionserver.
|
void |
ReplicationQueueStorage.setWALPosition(ServerName serverName,
String queueId,
String fileName,
long position,
Map<String,Long> lastSeqIds)
Set the current position for a specific WAL in a given queue for a given regionserver.
|
| Modifier and Type | Method and Description |
|---|---|
void |
HBaseReplicationEndpoint.setRegionServers(List<ServerName> regionServers)
Set the list of region servers for that peer
|
| Modifier and Type | Method and Description |
|---|---|
ServerName |
ReplicationSource.getServerWALsBelongTo() |
ServerName |
RecoveredReplicationSource.getServerWALsBelongTo() |
ServerName |
ReplicationSourceInterface.getServerWALsBelongTo()
The queue of WALs only belong to one region server.
|
| Modifier and Type | Method and Description |
|---|---|
protected List<ServerName> |
ReplicationSinkManager.getSinksForTesting() |
| Constructor and Description |
|---|
SinkPeer(ServerName serverName,
AdminProtos.AdminService.BlockingInterface regionServer) |
| Modifier and Type | Method and Description |
|---|---|
ServerName |
RSGroupBasedLoadBalancer.randomAssignment(RegionInfo region,
List<ServerName> servers) |
| Modifier and Type | Method and Description |
|---|---|
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) |
| 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 | Method and Description |
|---|---|
static ServerName |
ProtobufUtil.parseServerNameFrom(byte[] data)
Get a ServerName from the passed in data bytes.
|
static ServerName |
ProtobufUtil.toServerName(HBaseProtos.ServerName proto)
Convert a protocol buffer ServerName to a ServerName
|
| Modifier and Type | Method and Description |
|---|---|
static List<ServerName> |
ProtobufUtil.toServerNameList(List<HBaseProtos.ServerName> proto)
Convert a list of protocol buffer ServerName to a list of ServerName
|
| Modifier and Type | Method and Description |
|---|---|
static AdminProtos.CloseRegionRequest |
ProtobufUtil.buildCloseRegionRequest(ServerName server,
byte[] regionName)
Create a CloseRegionRequest for a given region name
|
static AdminProtos.CloseRegionRequest |
ProtobufUtil.buildCloseRegionRequest(ServerName server,
byte[] regionName,
ServerName destinationServer) |
static AdminProtos.GetServerInfoResponse |
ResponseConverter.buildGetServerInfoResponse(ServerName serverName,
int webuiPort)
A utility to build a GetServerInfoResponse.
|
static MasterProtos.MoveRegionRequest |
RequestConverter.buildMoveRegionRequest(byte[] encodedRegionName,
ServerName destServerName)
Create a protocol buffer MoveRegionRequest
|
static AdminProtos.OpenRegionRequest |
RequestConverter.buildOpenRegionRequest(ServerName server,
List<Pair<RegionInfo,List<ServerName>>> regionOpenInfos)
Create a protocol buffer OpenRegionRequest to open a list of regions
|
static AdminProtos.OpenRegionRequest |
RequestConverter.buildOpenRegionRequest(ServerName server,
RegionInfo region,
List<ServerName> favoredNodes)
Create a protocol buffer OpenRegionRequest for a given region
|
static MasterProtos.RecommissionRegionServerRequest |
RequestConverter.buildRecommissionRegionServerRequest(ServerName server,
List<byte[]> encodedRegionNames) |
static void |
ProtobufUtil.closeRegion(org.apache.hbase.thirdparty.com.google.protobuf.RpcController controller,
AdminProtos.AdminService.BlockingInterface admin,
ServerName server,
byte[] regionName)
A helper to close a region given a region name
using admin protocol.
|
static void |
ProtobufUtil.openRegion(org.apache.hbase.thirdparty.com.google.protobuf.RpcController controller,
AdminProtos.AdminService.BlockingInterface admin,
ServerName server,
RegionInfo region)
A helper to open a region using admin protocol.
|
static WALProtos.RegionEventDescriptor |
ProtobufUtil.toRegionEventDescriptor(WALProtos.RegionEventDescriptor.EventType eventType,
byte[] tableNameAsBytes,
byte[] encodedNameAsBytes,
byte[] regionNameAsBytes,
long seqId,
ServerName server,
Map<byte[],List<org.apache.hadoop.fs.Path>> storeFiles) |
static WALProtos.RegionEventDescriptor |
ProtobufUtil.toRegionEventDescriptor(WALProtos.RegionEventDescriptor.EventType eventType,
RegionInfo hri,
long seqId,
ServerName server,
Map<byte[],List<org.apache.hadoop.fs.Path>> storeFiles) |
static HBaseProtos.ServerName |
ProtobufUtil.toServerName(ServerName serverName)
Convert a ServerName to a protocol buffer ServerName
|
| Modifier and Type | Method and Description |
|---|---|
static MasterProtos.ClearDeadServersRequest |
RequestConverter.buildClearDeadServersRequest(Collection<ServerName> deadServers) |
static MasterProtos.DecommissionRegionServersRequest |
RequestConverter.buildDecommissionRegionServersRequest(List<ServerName> servers,
boolean offload) |
static AdminProtos.OpenRegionRequest |
RequestConverter.buildOpenRegionRequest(ServerName server,
List<Pair<RegionInfo,List<ServerName>>> regionOpenInfos)
Create a protocol buffer OpenRegionRequest to open a list of regions
|
static AdminProtos.OpenRegionRequest |
RequestConverter.buildOpenRegionRequest(ServerName server,
RegionInfo region,
List<ServerName> favoredNodes)
Create a protocol buffer OpenRegionRequest for a given region
|
static AdminProtos.OpenRegionRequest.RegionOpenInfo |
RequestConverter.buildRegionOpenInfo(RegionInfo region,
List<ServerName> favoredNodes)
Create a RegionOpenInfo based on given region info and version of offline node
|
static AdminProtos.UpdateFavoredNodesRequest |
RequestConverter.buildUpdateFavoredNodesRequest(List<Pair<RegionInfo,List<ServerName>>> updateRegionInfos)
Create a protocol buffer UpdateFavoredNodesRequest to update a list of favorednode mappings
|
| Modifier and Type | Field and Description |
|---|---|
protected ServerName |
MasterStatusTmpl.metaLocation |
| Modifier and Type | Field and Description |
|---|---|
protected Set<ServerName> |
MasterStatusTmpl.deadServers |
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 |
|---|---|
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 | 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) |
| Modifier and Type | Method and Description |
|---|---|
void |
HBaseFsck.HbckInfo.addServer(RegionInfo hri,
ServerName server) |
void |
HBaseFsck.TableInfo.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.
|
| 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.
|
| 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.
|
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. |
Copyright © 2007–2019 Cloudera. All rights reserved.