Uses of Class org.apache.hadoop.hbase.ServerName (Apache HBase 1.2.12 API)

Packages that use ServerName
Package	Description
org.apache.hadoop.hbase
org.apache.hadoop.hbase.client	Provides HBase Client
org.apache.hadoop.hbase.client.backoff
org.apache.hadoop.hbase.coordination
org.apache.hadoop.hbase.coprocessor	Table of Contents
org.apache.hadoop.hbase.exceptions
org.apache.hadoop.hbase.ipc	Tools to help define network clients and servers.
org.apache.hadoop.hbase.master
org.apache.hadoop.hbase.master.balancer
org.apache.hadoop.hbase.master.handler
org.apache.hadoop.hbase.master.procedure
org.apache.hadoop.hbase.master.snapshot
org.apache.hadoop.hbase.regionserver
org.apache.hadoop.hbase.regionserver.handler
org.apache.hadoop.hbase.replication	Multi Cluster Replication
org.apache.hadoop.hbase.replication.regionserver
org.apache.hadoop.hbase.security.access
org.apache.hadoop.hbase.tmpl.master
org.apache.hadoop.hbase.util
org.apache.hadoop.hbase.wal
org.apache.hadoop.hbase.zookeeper

Uses of ServerName in org.apache.hadoop.hbase

Fields in org.apache.hadoop.hbase declared as ServerName
Modifier and Type	Field and Description
`private ServerName`	ClusterStatus.`master`
`private ServerName`	SplitLogTask.`originServer`
`private ServerName`	HRegionLocation.`serverName`

Fields in org.apache.hadoop.hbase with type parameters of type ServerName
Modifier and Type	Field and Description
`private Collection<ServerName>`	ClusterStatus.`backupMasters`
`private Collection<ServerName>`	ClusterStatus.`deadServers`
`static List<ServerName>`	ServerName.`EMPTY_SERVER_LIST`
`private Map<ServerName,ServerLoad>`	ClusterStatus.`liveServers`

Methods in org.apache.hadoop.hbase that return ServerName
Modifier and Type	Method and Description
`ServerName`	ClusterStatus.`getMaster()` Returns detailed information about the current master `ServerName`.
`ServerName`	RegionTransition.`getServerName()`
`ServerName`	HRegionLocation.`getServerName()`
`ServerName`	SplitLogTask.`getServerName()`
`ServerName`	Server.`getServerName()`
`static ServerName`	HRegionInfo.`getServerName(Result r)` Deprecated. use MetaTableAccessor methods for interacting with meta layouts
`private static ServerName`	MetaTableAccessor.`getServerName(Result r, int replicaId)` Returns a `ServerName` from catalog table `Result`.
`static ServerName`	ServerName.`parseFrom(byte[] data)` Get a ServerName from the passed in data bytes.
`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.

Methods in org.apache.hadoop.hbase that return types with arguments of type ServerName
Modifier and Type	Method and Description
`Collection<ServerName>`	ClusterStatus.`getBackupMasters()`
`Collection<ServerName>`	ClusterStatus.`getDeadServerNames()`
`static Pair<HRegionInfo,ServerName>`	HRegionInfo.`getHRegionInfoAndServerName(Result r)` Deprecated. use MetaTableAccessor methods for interacting with meta layouts
`static Pair<HRegionInfo,ServerName>`	MetaTableAccessor.`getRegion(Connection connection, byte[] regionName)` Deprecated. use `MetaTableAccessor.getRegionLocation(Connection, byte[])` instead
`Collection<ServerName>`	ClusterStatus.`getServerInfo()` Deprecated. As of release 0.92 (HBASE-1502). This will be removed in HBase 2.0.0. Use `ClusterStatus.getServers()`.
`Collection<ServerName>`	ClusterStatus.`getServers()`
`static List<Pair<HRegionInfo,ServerName>>`	MetaTableAccessor.`getTableRegionsAndLocations(ZooKeeperWatcher zkw, Connection connection, TableName tableName)`
`static List<Pair<HRegionInfo,ServerName>>`	MetaTableAccessor.`getTableRegionsAndLocations(ZooKeeperWatcher zkw, Connection connection, TableName tableName, boolean excludeOfflinedSplitParents)`

Methods in org.apache.hadoop.hbase with parameters of type ServerName
Modifier and Type	Method and Description
`static void`	MetaTableAccessor.`addDaughter(Connection connection, HRegionInfo regionInfo, ServerName sn, long openSeqNum)` Adds a daughter region entry to meta.
`static Put`	MetaTableAccessor.`addLocation(Put p, ServerName sn, long openSeqNum, long time, int replicaId)`
`int`	ServerName.`compareTo(ServerName other)`
`static RegionTransition`	RegionTransition.`createRegionTransition(EventType type, byte[] regionName, ServerName sn)`
`static RegionTransition`	RegionTransition.`createRegionTransition(EventType type, byte[] regionName, ServerName sn, byte[] payload)`
`ServerLoad`	ClusterStatus.`getLoad(ServerName sn)`
`static NavigableMap<HRegionInfo,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.`isSameHostnameAndPort(ServerName left, ServerName right)`
`boolean`	SplitLogTask.`isUnassigned(ServerName sn)`
`static void`	MetaTableAccessor.`mergeRegions(Connection connection, HRegionInfo mergedRegion, HRegionInfo regionA, HRegionInfo regionB, ServerName sn, int regionReplication, long masterSystemTime)` Merge the two regions into one in an atomic operation.
`RegionLocations`	RegionLocations.`removeByServer(ServerName serverName)` Returns a new RegionLocations with the locations removed (set to null) which have the destination server as given.
`static void`	MetaTableAccessor.`splitRegion(Connection connection, HRegionInfo parent, HRegionInfo splitA, HRegionInfo splitB, ServerName sn, int regionReplication)` Splits the region into two in an atomic operation.
`private static void`	MetaTableAccessor.`updateLocation(Connection connection, HRegionInfo 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, HRegionInfo 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.

Method parameters in org.apache.hadoop.hbase with type arguments of type ServerName
Modifier and Type	Method and Description
`(package private) static List<HRegionInfo>`	MetaTableAccessor.`getListOfHRegionInfos(List<Pair<HRegionInfo,ServerName>> pairs)`

Constructors in org.apache.hadoop.hbase with parameters of type ServerName
Constructor and Description
`ClusterStatus(String hbaseVersion, String clusterid, Map<ServerName,ServerLoad> servers, Collection<ServerName> deadServers, ServerName master, Collection<ServerName> backupMasters, Map<String,RegionState> rit, String[] masterCoprocessors, Boolean balancerOn)`
`HRegionLocation(HRegionInfo regionInfo, ServerName serverName)`
`HRegionLocation(HRegionInfo regionInfo, ServerName serverName, long seqNum)`
`SplitLogTask.Done(ServerName originServer, org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode mode)`
`SplitLogTask.Err(ServerName originServer, org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode mode)`
`SplitLogTask.Owned(ServerName originServer, org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode mode)`
`SplitLogTask.Resigned(ServerName originServer, org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode mode)`
`SplitLogTask.Unassigned(ServerName originServer, org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode mode)`
`SplitLogTask(ServerName originServer, org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.State state, org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode mode)`

Constructor parameters in org.apache.hadoop.hbase with type arguments of type ServerName
Constructor and Description
`ClusterStatus(String hbaseVersion, String clusterid, Map<ServerName,ServerLoad> servers, Collection<ServerName> deadServers, ServerName master, Collection<ServerName> backupMasters, Map<String,RegionState> rit, String[] masterCoprocessors, Boolean balancerOn)`
`ClusterStatus(String hbaseVersion, String clusterid, Map<ServerName,ServerLoad> servers, Collection<ServerName> deadServers, ServerName master, Collection<ServerName> backupMasters, Map<String,RegionState> rit, String[] masterCoprocessors, Boolean balancerOn)`
`ClusterStatus(String hbaseVersion, String clusterid, Map<ServerName,ServerLoad> servers, Collection<ServerName> deadServers, ServerName master, Collection<ServerName> backupMasters, Map<String,RegionState> rit, String[] masterCoprocessors, Boolean balancerOn)`

Uses of ServerName in org.apache.hadoop.hbase.client

Fields in org.apache.hadoop.hbase.client declared as ServerName
Modifier and Type	Field and Description
`private ServerName`	FastFailInterceptorContext.`server`
`private ServerName`	AsyncProcess.AsyncRequestFutureImpl.SingleServerRequestRunnable.`server`
`private ServerName`	CoprocessorHConnection.`serverName`

Fields in org.apache.hadoop.hbase.client with type parameters of type ServerName
Modifier and Type	Field and Description
`private Set<ServerName>`	MetaCache.`cachedServers`
`private List<ServerName>`	ClusterStatusListener.`deadServers`
`private ConcurrentMap<ServerName,ConnectionManager.ServerErrorTracker.ServerErrors>`	ConnectionManager.ServerErrorTracker.`errorsByServer`
`protected ConcurrentMap<ServerName,FailureInfo>`	PreemptiveFastFailInterceptor.`repeatedFailuresMap`
`protected ConcurrentHashMap<ServerName,ConcurrentMap<byte[],MetricsConnection.RegionStats>>`	MetricsConnection.`serverStats`
`private ConcurrentHashMap<ServerName,ServerStatistics>`	ServerStatisticTracker.`stats`
`protected ConcurrentMap<ServerName,AtomicInteger>`	AsyncProcess.`taskCounterPerServer`

Methods in org.apache.hadoop.hbase.client that return ServerName
Modifier and Type	Method and Description
`ServerName`	FastFailInterceptorContext.`getServer()`
`(package private) ServerName`	MultiServerCallable.`getServerName()`

Methods in org.apache.hadoop.hbase.client that return types with arguments of type ServerName
Modifier and Type	Method and Description
`static NavigableMap<HRegionInfo,ServerName>`	MetaScanner.`allTableRegions(org.apache.hadoop.conf.Configuration conf, Connection connection, TableName tableName, boolean offlined)` Deprecated. Use `MetaScanner.allTableRegions(Connection, TableName)` instead
`static NavigableMap<HRegionInfo,ServerName>`	MetaScanner.`allTableRegions(Connection connection, TableName tableName)` Lists all of the table regions currently in META.
`(package private) Pair<HRegionInfo,ServerName>`	HBaseAdmin.`getRegion(byte[] regionName)`
`NavigableMap<HRegionInfo,ServerName>`	HTable.`getRegionLocations()` Deprecated. This is no longer a public API. Use `HTable.getAllRegionLocations()` instead.

Methods in org.apache.hadoop.hbase.client with parameters of type ServerName
Modifier and Type	Method and Description
`void`	AsyncProcess.BatchErrors.`add(Throwable ex, Row row, ServerName serverName)`
`private static void`	AsyncProcess.`addAction(ServerName server, byte[] regionName, Action<Row> action, Map<ServerName,MultiAction<Row>> actionsByServer, long nonceGroup)` Helper that is used when grouping the actions per region server.
`private void`	ConnectionManager.HConnectionImplementation.`cacheLocation(TableName tableName, ServerName source, HRegionLocation location)` Put a newly discovered HRegionLocation into the cache.
`void`	MetaCache.`cacheLocation(TableName tableName, ServerName source, HRegionLocation location)` Put a newly discovered HRegionLocation into the cache.
`(package private) long`	ConnectionManager.ServerErrorTracker.`calculateBackoffTime(ServerName server, long basePause)` Calculates the back-off time for a retrying request to a particular server.
`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`	ConnectionManager.HConnectionImplementation.`clearCaches(ServerName serverName)`
`void`	ConnectionAdapter.`clearCaches(ServerName sn)` Deprecated.
`void`	HConnection.`clearCaches(ServerName sn)` Deprecated. internal method, do not use thru HConnection
`void`	ClusterConnection.`clearCaches(ServerName sn)` Clear any caches that pertain to server name `sn`.
`void`	HBaseAdmin.`closeRegion(ServerName sn, HRegionInfo hri)` Close a region.
`void`	Admin.`closeRegion(ServerName sn, HRegionInfo hri)` Close a region.
`private void`	HBaseAdmin.`compact(ServerName sn, HRegionInfo hri, boolean major, byte[] family)`
`void`	HBaseAdmin.`compactRegionServer(ServerName sn, boolean major)` Compact all regions on the region server
`void`	Admin.`compactRegionServer(ServerName sn, boolean major)` Compact all regions on the region server
`CoprocessorRpcChannel`	HBaseAdmin.`coprocessorService(ServerName sn)` Creates and returns a `RpcChannel` instance connected to the passed region server.
`CoprocessorRpcChannel`	Admin.`coprocessorService(ServerName sn)` Creates and returns a `RpcChannel` instance connected to the passed region server.
`protected MultiServerCallable<Row>`	AsyncProcess.`createCallable(ServerName server, TableName tableName, MultiAction<Row> multi)` Create a callable.
`private String`	AsyncProcess.AsyncRequestFutureImpl.`createLog(int numAttempt, int failureCount, int replaySize, ServerName sn, Throwable error, long backOffTime, boolean willRetry, String startTime, int failed, int stopped)`
`static ClusterConnection`	ConnectionUtils.`createShortCircuitConnection(org.apache.hadoop.conf.Configuration conf, ExecutorService pool, User user, ServerName serverName, org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface admin, org.apache.hadoop.hbase.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.
`static ClusterConnection`	ConnectionUtils.`createShortCircuitHConnection(Connection conn, ServerName serverName, org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface admin, org.apache.hadoop.hbase.protobuf.generated.ClientProtos.ClientService.BlockingInterface client)` Deprecated.
`protected void`	AsyncProcess.`decTaskCounters(Collection<byte[]> regions, ServerName sn)` Decrements the counters for a given region and the region server.
`private void`	HBaseAdmin.`flush(ServerName sn, HRegionInfo hri)`
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	ConnectionManager.HConnectionImplementation.`getAdmin(ServerName serverName)`
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	ConnectionAdapter.`getAdmin(ServerName serverName)` Deprecated.
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	HConnection.`getAdmin(ServerName serverName)` Deprecated. internal method, do not use thru HConnection
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	ClusterConnection.`getAdmin(ServerName serverName)` Establishes a connection to the region server at the specified address.
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	ConnectionManager.HConnectionImplementation.`getAdmin(ServerName serverName, boolean master)`
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	ConnectionAdapter.`getAdmin(ServerName serverName, boolean getMaster)` Deprecated.
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	HConnection.`getAdmin(ServerName serverName, boolean getMaster)` Deprecated. You can pass master flag but nothing special is done.
`private Long`	AsyncProcess.AsyncRequestFutureImpl.`getBackoff(ServerName server, byte[] regionName)`
`org.apache.hadoop.hbase.protobuf.generated.ClientProtos.ClientService.BlockingInterface`	ConnectionManager.HConnectionImplementation.`getClient(ServerName sn)`
`org.apache.hadoop.hbase.protobuf.generated.ClientProtos.ClientService.BlockingInterface`	ConnectionAdapter.`getClient(ServerName serverName)` Deprecated.
`org.apache.hadoop.hbase.protobuf.generated.ClientProtos.ClientService.BlockingInterface`	HConnection.`getClient(ServerName serverName)` Deprecated. internal method, do not use thru HConnection
`org.apache.hadoop.hbase.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.protobuf.generated.ClientProtos.ClientService.BlockingInterface`	CoprocessorHConnection.`getClient(ServerName serverName)`
`private Collection<? extends Runnable>`	AsyncProcess.AsyncRequestFutureImpl.`getNewMultiActionRunnable(ServerName server, MultiAction<Row> multiAction, int numAttempt)`
`List<HRegionInfo>`	HBaseAdmin.`getOnlineRegions(ServerName sn)` Get all the online regions on a region server.
`List<HRegionInfo>`	Admin.`getOnlineRegions(ServerName sn)` Get all the online regions on a region server.
`(package private) ServerStatistics`	ServerStatisticTracker.`getServerStatsForTesting(ServerName server)`
`ServerStatistics`	ServerStatisticTracker.`getStats(ServerName server)`
`private 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.lang.mutable.MutableBoolean couldNotCommunicateWithServer)`
`protected void`	AsyncProcess.`incTaskCounters(Collection<byte[]> regions, ServerName sn)` increment the tasks counters for a given set of regions.
`private boolean`	PreemptiveFastFailInterceptor.`inFastFailMode(ServerName server)` Checks to see if we are in the Fast fail mode for requests to the server.
`boolean`	ConnectionManager.HConnectionImplementation.`isDeadServer(ServerName sn)`
`boolean`	ConnectionAdapter.`isDeadServer(ServerName serverName)` Deprecated.
`boolean`	HConnection.`isDeadServer(ServerName serverName)` Deprecated. internal method, do not use thru HConnection
`boolean`	ClusterConnection.`isDeadServer(ServerName serverName)` Deprecated. internal method, do not use thru HConnection
`boolean`	ClusterStatusListener.`isDeadServer(ServerName sn)` Check if we know if a server is dead.
`protected boolean`	PreemptiveFastFailInterceptor.`isServerInFailureMap(ServerName serverName)`
`private void`	AsyncProcess.AsyncRequestFutureImpl.`logNoResubmit(ServerName oldServer, int numAttempt, int failureCount, Throwable throwable, int failed, int stopped)`
`AsyncProcess.Retry`	AsyncProcess.AsyncRequestFutureImpl.`manageError(int originalIndex, Row row, AsyncProcess.Retry canRetry, Throwable throwable, ServerName server)` Check that we can retry acts accordingly: logs, set the error status.
`void`	ClusterStatusListener.DeadServerHandler.`newDead(ServerName sn)` Called when a server is identified as dead.
`private void`	AsyncProcess.AsyncRequestFutureImpl.`receiveGlobalFailure(MultiAction<Row> rsActions, ServerName server, int numAttempt, Throwable t)` Resubmit all the actions from this multiaction after a failure.
`private void`	AsyncProcess.AsyncRequestFutureImpl.`receiveMultiAction(MultiAction<Row> multiAction, ServerName server, MultiResponse responses, int numAttempt)` Called when we receive the result of a server query.
`(package private) void`	ConnectionManager.ServerErrorTracker.`reportServerError(ServerName server)` Reports that there was an error on the server to do whatever bean-counting necessary.
`private void`	AsyncProcess.AsyncRequestFutureImpl.`resubmit(ServerName oldServer, List<Action<Row>> 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`	HBaseAdmin.`rollWALWriter(ServerName serverName)`
`void`	Admin.`rollWALWriter(ServerName serverName)` Roll the log writer.
`private org.apache.hadoop.hbase.protobuf.generated.AdminProtos.RollWALWriterResponse`	HBaseAdmin.`rollWALWriterImpl(ServerName sn)`
`private void`	AsyncProcess.AsyncRequestFutureImpl.`setError(int index, Row row, Throwable throwable, ServerName server)` Sets the error from a particular action.
`void`	FastFailInterceptorContext.`setServer(ServerName server)`
`void`	HBaseAdmin.`split(ServerName sn, HRegionInfo hri, byte[] splitPoint)`
`private AsyncProcess.ReplicaResultState`	AsyncProcess.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`	ConnectionManager.HConnectionImplementation.`updateCachedLocation(HRegionInfo hri, ServerName source, ServerName serverName, long seqNum)`
`void`	ConnectionManager.HConnectionImplementation.`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`	ConnectionAdapter.`updateCachedLocations(TableName tableName, byte[] regionName, byte[] rowkey, Object exception, ServerName source)` Deprecated.
`void`	HConnection.`updateCachedLocations(TableName tableName, byte[] regionName, byte[] rowkey, Object exception, ServerName source)` Deprecated. internal method, do not use thru HConnection
`void`	ClusterConnection.`updateCachedLocations(TableName tableName, byte[] regionName, byte[] rowkey, Object exception, ServerName source)` Update the location cache.
`void`	HBaseAdmin.`updateConfiguration(ServerName server)`
`void`	Admin.`updateConfiguration(ServerName server)` Update the configuration and trigger an online config change on the regionserver
`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`	ServerStatisticTracker.`updateRegionStats(ServerName server, byte[] region, org.apache.hadoop.hbase.protobuf.generated.ClientProtos.RegionLoadStats currentStats)`
`void`	MetricsConnection.`updateServerStats(ServerName serverName, byte[] regionName, Object r)`
`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`

Method parameters in org.apache.hadoop.hbase.client with type arguments of type ServerName
Modifier and Type	Method and Description
`private static void`	AsyncProcess.`addAction(ServerName server, byte[] regionName, Action<Row> action, Map<ServerName,MultiAction<Row>> actionsByServer, long nonceGroup)` Helper that is used when grouping the actions per region server.
`private void`	AsyncProcess.AsyncRequestFutureImpl.ReplicaCallIssuingRunnable.`addReplicaActions(int index, Map<ServerName,MultiAction<Row>> actionsByServer, List<Action<Row>> unknownReplicaActions)` Add replica actions to action map by server.
`private void`	AsyncProcess.AsyncRequestFutureImpl.ReplicaCallIssuingRunnable.`addReplicaActionsAgain(Action<Row> action, Map<ServerName,MultiAction<Row>> actionsByServer)`
`protected boolean`	AsyncProcess.`canTakeOperation(HRegionLocation loc, Map<HRegionInfo,Boolean> regionsIncluded, Map<ServerName,Boolean> serversIncluded)` Check if we should send new operations to this region or region server.
`private void`	AsyncProcess.AsyncRequestFutureImpl.`sendMultiAction(Map<ServerName,MultiAction<Row>> actionsByServer, int numAttempt, List<Action<Row>> actionsForReplicaThread, boolean reuseThread)` Send a multi action structure to the servers, after a delay depending on the attempt number.
`(package private) <CResult> AsyncProcess.AsyncRequestFuture`	AsyncProcess.`submitMultiActions(TableName tableName, List<Action<Row>> retainedActions, long nonceGroup, Batch.Callback<CResult> callback, Object[] results, boolean needResults, List<Exception> locationErrors, List<Integer> locationErrorRows, Map<ServerName,MultiAction<Row>> actionsByServer, ExecutorService pool)`

Constructors in org.apache.hadoop.hbase.client with parameters of type ServerName
Constructor and Description
`AsyncProcess.AsyncRequestFutureImpl.SingleServerRequestRunnable(MultiAction<Row> multiAction, int numAttempt, ServerName server, Set<MultiServerCallable<Row>> callsInProgress)`
`MultiServerCallable(ClusterConnection connection, TableName tableName, ServerName location, RpcControllerFactory rpcFactory, MultiAction<R> multi)`

Uses of ServerName in org.apache.hadoop.hbase.client.backoff

Methods in org.apache.hadoop.hbase.client.backoff with parameters of type ServerName
Modifier and Type	Method and Description
`long`	ExponentialClientBackoffPolicy.`getBackoffTime(ServerName serverName, byte[] region, ServerStatistics stats)`
`long`	ClientBackoffPolicyFactory.NoBackoffPolicy.`getBackoffTime(ServerName serverName, byte[] region, ServerStatistics stats)`
`long`	ClientBackoffPolicy.`getBackoffTime(ServerName serverName, byte[] region, ServerStatistics stats)`

Uses of ServerName in org.apache.hadoop.hbase.coordination

Fields in org.apache.hadoop.hbase.coordination declared as ServerName
Modifier and Type	Field and Description
`private ServerName`	SplitLogManagerCoordination.SplitLogManagerDetails.`serverName`
`private ServerName`	ZkOpenRegionCoordination.ZkOpenRegionDetails.`serverName` Server name the handler is running on.

Methods in org.apache.hadoop.hbase.coordination that return ServerName
Modifier and Type	Method and Description
`ServerName`	OpenRegionCoordination.OpenRegionDetails.`getServerName()`
`ServerName`	SplitLogManagerCoordination.SplitLogManagerDetails.`getServerName()`
`ServerName`	ZkOpenRegionCoordination.ZkOpenRegionDetails.`getServerName()`

Methods in org.apache.hadoop.hbase.coordination with parameters of type ServerName
Modifier and Type	Method and Description
`protected static int`	ZkSplitLogWorkerCoordination.`attemptToOwnTask(boolean isFirstTime, ZooKeeperWatcher zkw, ServerName server, String task, org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode mode, int taskZKVersion)` Try to own the task by transitioning the zk node data from UNASSIGNED to OWNED.
`void`	ZkRegionMergeCoordination.`confirmRegionMergeTransaction(HRegionInfo merged, HRegionInfo a, HRegionInfo b, ServerName serverName, RegionMergeCoordination.RegionMergeDetails rmd)`
`void`	RegionMergeCoordination.`confirmRegionMergeTransaction(HRegionInfo merged, HRegionInfo a, HRegionInfo b, ServerName serverName, RegionMergeCoordination.RegionMergeDetails rmd)` Confirm that the region merge can be performed
`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)`
`void`	SplitLogManagerCoordination.`markRegionsRecovering(ServerName serverName, Set<HRegionInfo> userRegions)` Mark regions in recovering state for distributed log replay
`void`	ZKSplitLogManagerCoordination.`markRegionsRecovering(ServerName serverName, Set<HRegionInfo> userRegions)` Create znodes /hbase/recovering-regions/[region_ids...]/[failed region server names ...] for all regions of the passed in region servers
`void`	ZkRegionMergeCoordination.`processRegionMergeRequest(HRegionInfo p, HRegionInfo hri_a, HRegionInfo hri_b, ServerName sn, RegionMergeCoordination.RegionMergeDetails rmd)`
`void`	RegionMergeCoordination.`processRegionMergeRequest(HRegionInfo merged, HRegionInfo a, HRegionInfo b, ServerName serverName, RegionMergeCoordination.RegionMergeDetails rmd)`
`int`	ZKSplitTransactionCoordination.`processTransition(HRegionInfo p, HRegionInfo hri_a, HRegionInfo hri_b, ServerName sn, SplitTransactionCoordination.SplitTransactionDetails std)`
`int`	SplitTransactionCoordination.`processTransition(HRegionInfo p, HRegionInfo hri_a, HRegionInfo hri_b, ServerName sn, SplitTransactionCoordination.SplitTransactionDetails std)` Required by AssignmentManager
`private boolean`	ZKSplitLogManagerCoordination.`resubmit(ServerName serverName, String path, int version)`
`void`	ZkCloseRegionCoordination.`setClosedState(HRegion region, ServerName sn, CloseRegionCoordination.CloseRegionDetails crd)` In ZK-based version we do some znodes transitioning.
`void`	CloseRegionCoordination.`setClosedState(HRegion region, ServerName sn, CloseRegionCoordination.CloseRegionDetails crd)` Called after region is closed to notify all interesting parties / "register" region as finally closed.
`private boolean`	ZkCloseRegionCoordination.`setClosedState(HRegion region, ServerName sn, ZkCloseRegionCoordination.ZkCloseRegionDetails zkCrd)` Transition ZK node to CLOSED
`void`	OpenRegionCoordination.OpenRegionDetails.`setServerName(ServerName serverName)` Sets server name on which opening operation is running.
`void`	ZkOpenRegionCoordination.ZkOpenRegionDetails.`setServerName(ServerName serverName)`
`void`	ZkRegionMergeCoordination.`startRegionMergeTransaction(HRegionInfo region, ServerName serverName, HRegionInfo a, HRegionInfo b)` Creates a new ephemeral node in the PENDING_MERGE state for the merged region.
`void`	RegionMergeCoordination.`startRegionMergeTransaction(HRegionInfo region, ServerName serverName, HRegionInfo a, HRegionInfo b)` Start the region merge transaction
`void`	ZKSplitTransactionCoordination.`startSplitTransaction(HRegion parent, ServerName serverName, HRegionInfo hri_a, HRegionInfo hri_b)` Creates a new ephemeral node in the PENDING_SPLIT state for the specified region.
`void`	SplitTransactionCoordination.`startSplitTransaction(HRegion parent, ServerName serverName, HRegionInfo hri_a, HRegionInfo hri_b)` init coordination for split transaction
`private void`	ZkRegionMergeCoordination.`transitionMergingNode(HRegionInfo merged, HRegionInfo a, HRegionInfo b, ServerName serverName, RegionMergeCoordination.RegionMergeDetails rmd, EventType beginState, EventType endState)` Transitions an existing ephemeral node for the specified region which is currently in the begin state to be in the end state.
`private int`	ZKSplitTransactionCoordination.`transitionSplittingNode(HRegionInfo parent, HRegionInfo a, HRegionInfo b, ServerName serverName, SplitTransactionCoordination.SplitTransactionDetails std, EventType beginState, EventType endState)` Transitions an existing ephemeral node for the specified region which is currently in the begin state to be in the end state.

Constructors in org.apache.hadoop.hbase.coordination with parameters of type ServerName
Constructor and Description
`SplitLogManagerCoordination.SplitLogManagerDetails(ConcurrentMap<String,SplitLogManager.Task> tasks, MasterServices master, Set<String> failedDeletions, ServerName serverName)`
`ZKSplitLogManagerCoordination.ZkSplitLogManagerDetails(ConcurrentMap<String,SplitLogManager.Task> tasks, MasterServices master, Set<String> failedDeletions, ServerName serverName)`

Uses of ServerName in org.apache.hadoop.hbase.coprocessor

Methods in org.apache.hadoop.hbase.coprocessor with parameters of type ServerName
Modifier and Type	Method and Description
`void`	MasterObserver.`postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)` Called after the region move has been requested.
`void`	BaseMasterObserver.`postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)`
`void`	BaseMasterAndRegionObserver.`postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)`
`void`	MasterObserver.`preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)` Called prior to moving a given region from one region server to another.
`void`	BaseMasterObserver.`preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)`
`void`	BaseMasterAndRegionObserver.`preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)`

Uses of ServerName in org.apache.hadoop.hbase.exceptions

Methods in org.apache.hadoop.hbase.exceptions that return ServerName
Modifier and Type	Method and Description
`ServerName`	RegionMovedException.`getServerName()`

Constructors in org.apache.hadoop.hbase.exceptions with parameters of type ServerName
Constructor and Description
`PreemptiveFastFailException(long count, long timeOfFirstFailureMilliSec, long timeOfLatestAttemptMilliSec, ServerName serverName)`
`RegionMovedException(ServerName serverName, long locationSeqNum)`

Uses of ServerName in org.apache.hadoop.hbase.ipc

Fields in org.apache.hadoop.hbase.ipc declared as ServerName
Modifier and Type	Field and Description
`private ServerName`	RegionServerCoprocessorRpcChannel.`serverName`

Methods in org.apache.hadoop.hbase.ipc with parameters of type ServerName
Modifier and Type	Method and Description
`void`	RpcClientImpl.`cancelConnections(ServerName sn)` Interrupt the connections to the given ip:port server.
`void`	RpcClient.`cancelConnections(ServerName sn)` Interrupt the connections to the given server.
`void`	AsyncRpcClient.`cancelConnections(ServerName sn)` Interrupt the connections to the given ip:port server.
`com.google.protobuf.BlockingRpcChannel`	RpcClient.`createBlockingRpcChannel(ServerName sn, User user, int rpcTimeout)` Creates a "channel" that can be used by a blocking protobuf service.
`com.google.protobuf.BlockingRpcChannel`	AbstractRpcClient.`createBlockingRpcChannel(ServerName sn, User ticket, int defaultOperationTimeout)`
`com.google.protobuf.RpcChannel`	AsyncRpcClient.`createRpcChannel(ServerName sn, User user, int rpcTimeout)` Creates a "channel" that can be used by a protobuf service.

Constructors in org.apache.hadoop.hbase.ipc with parameters of type ServerName
Constructor and Description
`AbstractRpcClient.BlockingRpcChannelImplementation(AbstractRpcClient rpcClient, ServerName sn, User ticket, int channelOperationTimeout)`
`AsyncRpcClient.RpcChannelImplementation(AsyncRpcClient rpcClient, ServerName sn, User ticket, int channelOperationTimeout)`
`RegionServerCoprocessorRpcChannel(ClusterConnection conn, ServerName serverName)`

Uses of ServerName in org.apache.hadoop.hbase.master

Fields in org.apache.hadoop.hbase.master declared as ServerName
Modifier and Type	Field and Description
`ServerName`	SplitLogManager.Task.`cur_worker_name`
`private ServerName`	RegionPlan.`dest`
`private ServerName`	OfflineCallback.`destination`
`private ServerName`	OfflineCallback.ExistCallback.`destination`
`static ServerName`	AssignmentManager.`HBCK_CODE_SERVERNAME`
`private ServerName`	GeneralBulkAssigner.SingleServerBulkAssigner.`regionserver`
`private ServerName`	RegionState.`serverName`
`private ServerName`	TableLockManager.ZKTableLockManager.`serverName`
`(package private) ServerName`	TableLockManager.ZKTableLockManager.TableLockImpl.`serverName`
`private ServerName`	ActiveMasterManager.`sn`
`private ServerName`	RegionPlan.`source`

Fields in org.apache.hadoop.hbase.master with type parameters of type ServerName
Modifier and Type	Field and Description
`(package private) Map<ServerName,List<HRegionInfo>>`	GeneralBulkAssigner.`bulkPlan`
`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 Map<ServerName,List<HRegionInfo>>`	GeneralBulkAssigner.`failedPlans`
`private Map<ServerName,List<HRegionInfo>>`	GeneralBulkAssigner.SingleServerBulkAssigner.`failedPlans`
`private List<Pair<Set<ServerName>,Boolean>>`	SplitLogManager.`failedRecoveringRegionDeletions`
`private HashMap<String,ServerName>`	RegionStates.`lastAssignments` Encoded region name to server assignment map for re-assignment purpose.
`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 HashMap<String,ServerName>`	RegionStates.`oldAssignments` Encoded region name to server assignment map for the purpose to clean up serverHoldings when a region is online on a new server.
`private ConcurrentHashMap<ServerName,ServerLoad>`	ServerManager.`onlineServers` Map of registered servers to their current load
`private HashMap<ServerName,Long>`	RegionStates.`processedServers` Map a dead servers to the time when log split is done.
`private Set<ServerName>`	ServerManager.`queuedDeadServers` Set of region servers which are dead but not processed immediately.
`private TreeMap<HRegionInfo,ServerName>`	RegionStates.`regionAssignments` Region to server assignment map.
`private Map<ServerName,List<HRegionInfo>>`	SnapshotOfRegionAssignmentFromMeta.`regionServerToRegionMap` the regionServer to region map
`private Map<HRegionInfo,ServerName>`	SnapshotOfRegionAssignmentFromMeta.`regionToRegionServerMap` the region to region server map
`private Map<ServerName,Boolean>`	ServerManager.`requeuedDeadServers` Set of region servers which are dead and submitted to ServerShutdownHandler to process but not fully processed immediately.
`private Map<ServerName,org.apache.hadoop.hbase.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<HRegionInfo>>`	BulkReOpen.`rsToRegions`
`private Map<ServerName,Set<HRegionInfo>>`	RegionStates.`serverHoldings` Server to regions assignment map.
`private static Comparator<Pair<ServerName,Long>>`	DeadServer.`ServerNameDeathDateComparator`

Methods in org.apache.hadoop.hbase.master that return ServerName
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.
`(package private) ServerName`	RegionStates.`getLastRegionServerOfRegion(String encodedName)` Get the last region server a region was on for purpose of re-assignment, i.e.
`private ServerName`	MasterStatusServlet.`getMetaLocationOrNull(HMaster master)`
`(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(HRegionInfo hri)`
`ServerName`	RegionState.`getServerName()`
`ServerName`	HMaster.`getServerName()`
`ServerName`	RegionPlan.`getSource()` Get the source server for the plan for this region.
`ServerName`	LoadBalancer.`randomAssignment(HRegionInfo regionInfo, List<ServerName> servers)` Get a random region server from the list
`(package private) ServerName`	ServerManager.`regionServerStartup(org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionServerStartupRequest request, InetAddress ia)` Let the server manager know a new regionserver has come online

Methods in org.apache.hadoop.hbase.master that return types with arguments of type ServerName
Modifier and Type	Method and Description
`(package private) Map<HRegionInfo,ServerName>`	RegionStates.`closeAllUserRegions(Set<TableName> excludedTables)` At cluster clean re/start, mark all user regions closed except those of tables that are excluded, such as disabled/disabling/enabling tables.
`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(org.apache.hadoop.hbase.ServerName)` without server to exclude.
`List<ServerName>`	ServerManager.`createDestinationServersList(ServerName serverToExclude)` Creates a list of possible destinations for a region.
`protected List<ServerName>`	ClusterStatusPublisher.`generateDeadServersListToSend()` Create the dead server to send.
`protected Map<TableName,Map<ServerName,List<HRegionInfo>>>`	RegionStates.`getAssignmentsByTable()` This is an EXPENSIVE clone.
`(package private) Set<ServerName>`	ServerManager.`getDeadNotExpiredServers()`
`protected List<Pair<ServerName,Long>>`	ClusterStatusPublisher.`getDeadServers(long since)` Get the servers which died since a given timestamp.
`List<ServerName>`	ServerManager.`getDrainingServersList()`
`(package private) Set<ServerName>`	MasterFileSystem.`getFailedServersFromLogFolders()` Inspect the log directory to find dead servers which need recovery work
`static List<ServerName>`	RegionPlacementMaintainer.`getFavoredNodeList(String favoredNodesStr)`
`Map<ServerName,ServerLoad>`	ServerManager.`getOnlineServers()`
`List<ServerName>`	ServerManager.`getOnlineServersList()`
`private Set<ServerName>`	HMaster.`getPreviouselyFailedMetaServersFromZK()` This function returns a set of region server names under hbase:meta recovering region ZK node
`Map<HRegionInfo,ServerName>`	RegionStates.`getRegionAssignments()`
`(package private) Map<ServerName,List<HRegionInfo>>`	RegionStates.`getRegionAssignments(Collection<HRegionInfo> regions)` Return the replicas (including default) for the regions grouped by ServerName
`protected Map<ServerName,List<HRegionInfo>>`	RegionStates.`getRegionAssignmentsByServer()` Returns a clone of region assignments per server
`Map<ServerName,List<HRegionInfo>>`	SnapshotOfRegionAssignmentFromMeta.`getRegionServerToRegionMap()` Get regionserver to region map
`Map<HRegionInfo,ServerName>`	SnapshotOfRegionAssignmentFromMeta.`getRegionToRegionServerMap()` Get region to region server map
`(package private) Map<ServerName,Boolean>`	ServerManager.`getRequeuedDeadServers()`
`Map<ServerName,List<HRegionInfo>>`	AssignmentManager.`getSnapShotOfAssignment(Collection<HRegionInfo> infos)`
`(package private) Pair<HRegionInfo,ServerName>`	HMaster.`getTableRegionForRow(TableName tableName, byte[] rowKey)` Return the region and current deployment for the region containing the given row.
`Map<HRegionInfo,ServerName>`	LoadBalancer.`immediateAssignment(List<HRegionInfo> regions, List<ServerName> servers)` Sync assign a region
`(package private) Set<ServerName>`	AssignmentManager.`rebuildUserRegions()` Rebuild the list of user regions and assignment information.
`Map<ServerName,List<HRegionInfo>>`	LoadBalancer.`retainAssignment(Map<HRegionInfo,ServerName> regions, List<ServerName> servers)` Assign regions to the previously hosting region server
`Map<ServerName,List<HRegionInfo>>`	LoadBalancer.`roundRobinAssignment(List<HRegionInfo> regions, List<ServerName> servers)` Perform a Round Robin assignment of regions.

Methods in org.apache.hadoop.hbase.master with parameters of type ServerName
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(HRegionInfo regionInfo, ServerName server)`
`boolean`	ServerManager.`addServerToDrainList(ServerName sn)`
`private void`	RegionStates.`addToServerHoldings(ServerName serverName, HRegionInfo hri)`
`(package private) boolean`	AssignmentManager.`assign(ServerName destination, List<HRegionInfo> regions)` Bulk assign regions to `destination`.
`private boolean`	AssignmentManager.`asyncSetOfflineInZooKeeper(RegionState state, org.apache.zookeeper.AsyncCallback.StringCallback cb, ServerName destination)` Set region as OFFLINED up in zookeeper asynchronously.
`(package private) boolean`	ServerManager.`checkAndRecordNewServer(ServerName serverName, ServerLoad 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 String`	AssignmentManager.`checkInStateForSplit(ServerName sn, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`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)`
`List<HRegionInfo>`	AssignmentManager.`cleanOutCrashedServerReferences(ServerName sn)` Clean out crashed server removing any assignments.
`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, HRegionInfo region, long timeout)` Contacts a region server and waits up to timeout ms to close the region.
`List<ServerName>`	ServerManager.`createDestinationServersList(ServerName serverToExclude)` Creates a list of possible destinations for a region.
`RegionState`	RegionStates.`createRegionState(HRegionInfo hri, RegionState.State newState, ServerName serverName, ServerName lastHost)` Add a region to RegionStates with the specified state.
`static TableLockManager`	TableLockManager.`createTableLockManager(org.apache.hadoop.conf.Configuration conf, ZooKeeperWatcher zkWatcher, ServerName serverName)` Creates and returns a TableLockManager according to the configuration
`void`	AssignmentManager.`deleteClosingOrClosedNode(HRegionInfo region, ServerName sn)`
`private void`	AssignmentManager.`deleteMergingNode(String encodedName, ServerName sn)`
`private boolean`	AssignmentManager.`deleteNodeInStates(String encodedName, String desc, ServerName sn, EventType... types)`
`private void`	AssignmentManager.`deleteSplittingNode(String encodedName, ServerName sn)`
`(package private) boolean`	RegionStates.`existsInServerHoldings(ServerName serverName, HRegionInfo hri)` Used in some unit tests
`void`	ServerManager.`expireServer(ServerName serverName)`
`private ServerName`	ServerManager.`findServerWithSameHostnamePortWithLock(ServerName serverName)` Assumes onlineServers is locked.
`void`	DeadServer.`finish(ServerName sn)`
`ServerLoad`	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.
`private RegionPlan`	AssignmentManager.`getRegionPlan(HRegionInfo region, ServerName serverToExclude, boolean forceNewPlan)`
`int`	HMaster.`getRegionServerInfoPort(ServerName sn)`
`String`	HMaster.`getRegionServerVersion(ServerName sn)`
`private org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	ServerManager.`getRsAdmin(ServerName sn)`
`Set<HRegionInfo>`	RegionStates.`getServerRegions(ServerName serverName)` Get a copy of all regions assigned to a server
`Date`	DeadServer.`getTimeOfDeath(ServerName deadServerName)` Get the time when a server died
`(package private) void`	SplitLogManager.`handleDeadWorker(ServerName workerName)`
`private boolean`	AssignmentManager.`handleRegionMerging(RegionTransition rt, String encodedName, String prettyPrintedRegionName, ServerName sn)` A helper to handle region merging transition event.
`private boolean`	AssignmentManager.`handleRegionSplitting(RegionTransition rt, String encodedName, String prettyPrintedRegionName, ServerName sn)` A helper to handle region splitting transition event.
`void`	SplitLogManager.Task.`heartbeat(long time, int version, ServerName worker)`
`AssignmentManager.ServerHostRegion`	AssignmentManager.`isCarryingMeta(ServerName serverName)`
`AssignmentManager.ServerHostRegion`	AssignmentManager.`isCarryingMetaReplica(ServerName serverName, HRegionInfo metaHri)`
`AssignmentManager.ServerHostRegion`	AssignmentManager.`isCarryingMetaReplica(ServerName serverName, int replicaId)`
`private AssignmentManager.ServerHostRegion`	AssignmentManager.`isCarryingRegion(ServerName serverName, HRegionInfo hri)` Check if the shutdown server carries the specific region.
`boolean`	DeadServer.`isDeadServer(ServerName serverName)`
`boolean`	RegionState.`isOnServer(ServerName sn)`
`boolean`	RegionState.`isOpenOrMergingNewOnServer(ServerName sn)`
`boolean`	RegionState.`isOpenOrMergingOnServer(ServerName sn)`
`boolean`	RegionState.`isOpenOrSplittingNewOnServer(ServerName sn)`
`boolean`	RegionState.`isOpenOrSplittingOnServer(ServerName sn)`
`boolean`	RegionState.`isPendingCloseOrClosingOnServer(ServerName sn)`
`boolean`	RegionState.`isPendingOpenOrOpeningOnServer(ServerName sn)`
`boolean`	ServerManager.`isServerDead(ServerName serverName)` Check if a server is known to be dead.
`(package private) boolean`	RegionStates.`isServerDeadAndNotProcessed(ServerName server)`
`boolean`	ServerManager.`isServerOnline(ServerName serverName)`
`boolean`	ServerManager.`isServerReachable(ServerName server)` Check if a region server is reachable and has the expected start code
`boolean`	ServerManager.`isServerWithSameHostnamePortOnline(ServerName serverName)` Check whether a server is online based on hostname and port
`void`	RegionStates.`logSplit(ServerName serverName)` A dead server's wals have been split so that all the regions used to be open on it can be safely assigned now.
`void`	SplitLogManager.`markRegionsRecovering(ServerName server, Set<HRegionInfo> userRegions)`
`(package private) void`	RegionStates.`mergeRegions(HRegionInfo p, HRegionInfo a, HRegionInfo b, ServerName sn)`
`(package private) void`	RegionStateStore.`mergeRegions(HRegionInfo p, HRegionInfo a, HRegionInfo b, ServerName sn, int regionReplication)`
`void`	ServerManager.`moveFromOnelineToDeadServers(ServerName sn)`
`void`	DeadServer.`notifyServer(ServerName sn)` Notify that we started processing this dead server.
`private void`	AssignmentManager.`onRegionFailedOpen(HRegionInfo hri, ServerName sn)`
`private String`	AssignmentManager.`onRegionMerge(ServerName sn, org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`private String`	AssignmentManager.`onRegionMergeReverted(ServerName sn, org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`private void`	AssignmentManager.`onRegionOpen(HRegionInfo hri, ServerName sn, long openSeqNum)`
`private String`	AssignmentManager.`onRegionSplit(ServerName sn, org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`private String`	AssignmentManager.`onRegionSplitReverted(ServerName sn, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`protected String`	AssignmentManager.`onRegionTransition(ServerName serverName, org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition transition)` Try to update some region states.
`void`	MasterCoprocessorHost.`postMove(HRegionInfo region, ServerName srcServer, ServerName destServer)`
`boolean`	MasterCoprocessorHost.`preMove(HRegionInfo region, ServerName srcServer, ServerName destServer)`
`void`	MasterFileSystem.`prepareLogReplay(ServerName serverName, Set<HRegionInfo> regions)` Mark regions in recovering state when distributedLogReplay are set true
`private void`	AssignmentManager.`processAlreadyOpenedRegion(HRegionInfo region, ServerName sn)`
`void`	ServerManager.`processDeadServer(ServerName serverName, boolean shouldSplitWal)`
`(package private) void`	ServerManager.`recordNewServerWithLock(ServerName serverName, ServerLoad sl)` Adds the onlineServers list.
`void`	LoadBalancer.`regionOnline(HRegionInfo regionInfo, ServerName sn)` Marks the region as online at balancer.
`void`	RegionStates.`regionOnline(HRegionInfo hri, ServerName serverName)`
`(package private) void`	AssignmentManager.`regionOnline(HRegionInfo regionInfo, ServerName sn)` Marks the region as online.
`void`	RegionStates.`regionOnline(HRegionInfo hri, ServerName serverName, long openSeqNum)` A region is online, won't be in transition any more.
`(package private) void`	AssignmentManager.`regionOnline(HRegionInfo regionInfo, ServerName sn, long openSeqNum)`
`void`	AssignmentListener.`regionOpened(HRegionInfo regionInfo, ServerName serverName)` The region was opened on the specified server.
`(package private) void`	ServerManager.`regionServerReport(ServerName sn, ServerLoad sl)`
`private void`	RegionStates.`removeFromServerHoldings(ServerName serverName, HRegionInfo hri)`
`boolean`	ServerManager.`removeServerFromDrainList(ServerName sn)`
`boolean`	ServerManager.`sendRegionClose(ServerName server, HRegionInfo region, int versionOfClosingNode)`
`boolean`	ServerManager.`sendRegionClose(ServerName server, HRegionInfo region, int versionOfClosingNode, ServerName dest, boolean transitionInZK)` Sends an CLOSE RPC to the specified server to close the specified region.
`RegionOpeningState`	ServerManager.`sendRegionOpen(ServerName server, HRegionInfo region, int versionOfOfflineNode, List<ServerName> favoredNodes)` Sends an OPEN RPC to the specified server to open the specified region.
`List<RegionOpeningState>`	ServerManager.`sendRegionOpen(ServerName server, List<Triple<HRegionInfo,Integer,List<ServerName>>> regionOpenInfos)` Sends an OPEN RPC to the specified server to open the specified region.
`private void`	AssignmentManager.`sendRegionOpenedNotification(HRegionInfo regionInfo, ServerName serverName)`
`void`	ServerManager.`sendRegionsMerge(ServerName server, HRegionInfo region_a, HRegionInfo region_b, boolean forcible)` Sends an MERGE REGIONS RPC to the specified server to merge the specified regions.
`void`	ServerManager.`sendRegionWarmup(ServerName server, HRegionInfo region)` Sends a WARMUP RPC to the specified server to warmup the specified region.
`void`	ServerListener.`serverAdded(ServerName serverName)` The server has joined the cluster.
`List<HRegionInfo>`	RegionStates.`serverOffline(ZooKeeperWatcher watcher, ServerName sn)` A server is offline, all regions on it are dead.
`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.
`(package private) void`	RegionStates.`setLastRegionServerOfRegion(ServerName serverName, String encodedName)`
`(package private) void`	RegionStates.`setLastRegionServerOfRegions(ServerName serverName, List<HRegionInfo> regionInfos)`
`private int`	AssignmentManager.`setOfflineInZooKeeper(RegionState state, ServerName destination)` Set region as OFFLINED up in zookeeper
`RegionState`	RegionStates.`setRegionStateTOCLOSED(byte[] regionName, ServerName serverName)` Set the region state to CLOSED
`RegionState`	RegionStates.`setRegionStateTOCLOSED(HRegionInfo regionInfo, ServerName serverName)` Set the region state to CLOSED
`void`	MasterFileSystem.`splitLog(ServerName serverName)`
`void`	MasterFileSystem.`splitMetaLog(ServerName serverName)` Specialized method to handle the splitting for meta WAL
`private void`	HMaster.`splitMetaLogBeforeAssignment(ServerName currentMetaServer)`
`(package private) void`	RegionStates.`splitRegion(HRegionInfo p, HRegionInfo a, HRegionInfo b, ServerName sn)`
`(package private) void`	RegionStateStore.`splitRegion(HRegionInfo p, HRegionInfo a, HRegionInfo b, ServerName sn, int regionReplication)`
`RegionState`	RegionStates.`transitionOpenFromPendingOpenOrOpeningOnServer(RegionTransition transition, RegionState fromState, ServerName sn)` Transition a region state to OPEN from OPENING/PENDING_OPEN
`void`	AssignmentManager.`unassign(HRegionInfo region, boolean force, ServerName dest)` Unassigns the specified region.
`private void`	AssignmentManager.`unassign(HRegionInfo region, RegionState state, int versionOfClosingNode, ServerName dest, boolean transitionInZK, ServerName src)` Send CLOSE RPC if the server is online, otherwise, offline the region.
`private void`	ServerManager.`updateLastFlushedSequenceIds(ServerName sn, ServerLoad hsl)` Updates last flushed sequence Ids for the regions on server sn
`RegionState`	RegionStates.`updateRegionState(HRegionInfo hri, RegionState.State state, ServerName serverName)` Update a region state.
`private RegionState`	RegionStates.`updateRegionState(HRegionInfo hri, RegionState.State state, ServerName serverName, long openSeqNum)` Update a region state.
`protected boolean`	AssignmentManager.`wasRegionOnDeadServerByMeta(HRegionInfo region, ServerName sn)`

Method parameters in org.apache.hadoop.hbase.master with type arguments of type ServerName
Modifier and Type	Method and Description
`private void`	AssignmentManager.`assign(int regions, int totalServers, String message, Map<ServerName,List<HRegionInfo>> bulkPlan)`
`void`	AssignmentManager.`assign(Map<HRegionInfo,ServerName> regions)` Assigns specified regions retaining assignments, if any.
`private void`	AssignmentManager.`assignAllUserRegions(Map<HRegionInfo,ServerName> allRegions)` Assigns all user regions, if any exist.
`(package private) void`	HMaster.`assignMeta(MonitoredTask status, Set<ServerName> previouslyFailedMetaRSs, int replicaId)` Check `hbase:meta` is assigned.
`private void`	HMaster.`assignMetaZkLess(RegionStates regionStates, RegionState regionState, long timeout, Set<ServerName> previouslyFailedRs)`
`List<RegionPlan>`	LoadBalancer.`balanceCluster(Map<ServerName,List<HRegionInfo>> clusterState)` Perform the major balance operation
`private List<org.apache.hadoop.fs.Path>`	MasterFileSystem.`getLogDirs(Set<ServerName> serverNames)`
`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)`
`Map<HRegionInfo,ServerName>`	LoadBalancer.`immediateAssignment(List<HRegionInfo> regions, List<ServerName> servers)` Sync assign a region
`private void`	AssignmentManager.`prepareDaughterReplicaForAssignment(HRegionInfo daughterHri, HRegionInfo parentHri, int replicaId, Map<HRegionInfo,ServerName> map)`
`private void`	AssignmentVerificationReport.`printHServerAddressSet(Set<ServerName> serverSet)`
`private void`	AssignmentManager.`processDeadServersAndRecoverLostRegions(Set<ServerName> deadServers)` Processes list of dead servers from result of hbase:meta scan and regions in RIT.
`(package private) boolean`	AssignmentManager.`processDeadServersAndRegionsInTransition(Set<ServerName> deadServers)` Process all regions that are in transition in zookeeper and also processes the list of dead servers.
`ServerName`	LoadBalancer.`randomAssignment(HRegionInfo regionInfo, List<ServerName> servers)` Get a random region server from the list
`(package private) void`	ServerManager.`removeDeadNotExpiredServers(List<ServerName> servers)` Loop through the deadNotExpired server list and remove them from the servers.
`private void`	SplitLogManager.`removeRecoveringRegions(Set<ServerName> serverNames, Boolean isMetaRecovery)` It removes recovering regions under /hbase/recovering-regions/[encoded region name] so that the region server hosting the region can allow reads to the recovered region
`(package private) void`	SplitLogManager.`removeStaleRecoveringRegions(Set<ServerName> failedServers)` It removes stale recovering regions under /hbase/recovering-regions/[encoded region name] during master initialization phase.
`(package private) void`	MasterFileSystem.`removeStaleRecoveringRegionsFromZK(Set<ServerName> failedServers)` Wrapper function on `SplitLogManager.removeStaleRecoveringRegions(Set)`
`Map<ServerName,List<HRegionInfo>>`	LoadBalancer.`retainAssignment(Map<HRegionInfo,ServerName> regions, List<ServerName> servers)` Assign regions to the previously hosting region server
`Map<ServerName,List<HRegionInfo>>`	LoadBalancer.`retainAssignment(Map<HRegionInfo,ServerName> regions, List<ServerName> servers)` Assign regions to the previously hosting region server
`Map<ServerName,List<HRegionInfo>>`	LoadBalancer.`roundRobinAssignment(List<HRegionInfo> regions, List<ServerName> servers)` Perform a Round Robin assignment of regions.
`RegionOpeningState`	ServerManager.`sendRegionOpen(ServerName server, HRegionInfo region, int versionOfOfflineNode, List<ServerName> favoredNodes)` Sends an OPEN RPC to the specified server to open the specified region.
`List<RegionOpeningState>`	ServerManager.`sendRegionOpen(ServerName server, List<Triple<HRegionInfo,Integer,List<ServerName>>> regionOpenInfos)` Sends an OPEN RPC to the specified server to open the specified region.
`void`	MasterFileSystem.`splitLog(Set<ServerName> serverNames)`
`void`	MasterFileSystem.`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`	MasterFileSystem.`splitMetaLog(Set<ServerName> serverNames)` Specialized method to handle the splitting for meta WAL

Constructors in org.apache.hadoop.hbase.master with parameters of type ServerName
Constructor and Description
`ActiveMasterManager(ZooKeeperWatcher watcher, ServerName sn, Server master)`
`GeneralBulkAssigner.SingleServerBulkAssigner(ServerName regionserver, List<HRegionInfo> regions, AssignmentManager am, Map<ServerName,List<HRegionInfo>> failedPlans)`
`OfflineCallback.ExistCallback(ServerName destination, AtomicInteger counter, Map<String,Integer> offlineNodesVersions)`
`OfflineCallback(ZooKeeperWatcher zkw, ServerName destination, AtomicInteger counter, Map<String,Integer> offlineNodesVersions)`
`RegionPlan(HRegionInfo 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(HRegionInfo region, RegionState.State state, long stamp, ServerName serverName)`
`RegionState(HRegionInfo region, RegionState.State state, ServerName serverName)`
`SplitLogManager(Server server, org.apache.hadoop.conf.Configuration conf, Stoppable stopper, MasterServices master, ServerName serverName)` Its OK to construct this object even when region-servers are not online.
`TableLockManager.ZKTableLockManager.TableLockImpl(TableName tableName, ZooKeeperWatcher zkWatcher, ServerName serverName, long lockTimeoutMs, boolean isShared, String purpose)`
`TableLockManager.ZKTableLockManager(ZooKeeperWatcher zkWatcher, ServerName serverName, long writeLockTimeoutMs, long readLockTimeoutMs, long lockExpireTimeoutMs)` Initialize a new manager for table-level locks.

Constructor parameters in org.apache.hadoop.hbase.master with type arguments of type ServerName
Constructor and Description
`BulkReOpen(Server server, Map<ServerName,List<HRegionInfo>> serverToRegions, AssignmentManager am)`
`GeneralBulkAssigner.SingleServerBulkAssigner(ServerName regionserver, List<HRegionInfo> regions, AssignmentManager am, Map<ServerName,List<HRegionInfo>> failedPlans)`
`GeneralBulkAssigner(Server server, Map<ServerName,List<HRegionInfo>> bulkPlan, AssignmentManager am, boolean waitTillAllAssigned)`

Uses of ServerName in org.apache.hadoop.hbase.master.balancer

Fields in org.apache.hadoop.hbase.master.balancer declared as ServerName
Modifier and Type	Field and Description
`protected ServerName`	BaseLoadBalancer.`masterServerName`
`(package private) ServerName[]`	BaseLoadBalancer.Cluster.`servers`
`private ServerName`	ServerAndLoad.`sn`

Fields in org.apache.hadoop.hbase.master.balancer with type parameters of type ServerName
Modifier and Type	Field and Description
`private Map<ServerName,List<HRegionInfo>>`	ClusterLoadState.`clusterState`
`(package private) Map<ServerName,List<HRegionInfo>>`	BaseLoadBalancer.Cluster.`clusterState`
`private Map<HRegionInfo,List<ServerName>>`	FavoredNodesPlan.`favoredNodesMap` the map between each region and its favored region server list
`private Map<String,List<ServerName>>`	FavoredNodeAssignmentHelper.`rackToRegionServerMap`
`private Map<ServerName,String>`	FavoredNodeAssignmentHelper.`regionServerToRackMap`
`private List<ServerName>`	FavoredNodeAssignmentHelper.`servers`

Methods in org.apache.hadoop.hbase.master.balancer that return ServerName
Modifier and Type	Method and Description
`private ServerName`	FavoredNodeLoadBalancer.`availableServersContains(List<ServerName> servers, ServerName favoredNode)`
`static ServerName[]`	FavoredNodeAssignmentHelper.`getFavoredNodesList(byte[] favoredNodes)`
`private ServerName`	FavoredNodeAssignmentHelper.`getOneRandomServer(String rack)`
`private ServerName`	FavoredNodeAssignmentHelper.`getOneRandomServer(String rack, Set<ServerName> skipServerSet)`
`(package private) ServerName`	ServerAndLoad.`getServerName()`
`private ServerName[]`	FavoredNodeAssignmentHelper.`multiRackCase(HRegionInfo regionInfo, ServerName primaryRS, String primaryRack)`
`private ServerName[]`	FavoredNodeAssignmentHelper.`multiRackCaseWithRestrictions(Map<ServerName,Set<HRegionInfo>> serverToPrimaries, Map<HRegionInfo,ServerName[]> secondaryAndTertiaryMap, String primaryRack, ServerName primaryRS, HRegionInfo regionInfo)`
`private ServerName`	BaseLoadBalancer.`randomAssignment(BaseLoadBalancer.Cluster cluster, HRegionInfo regionInfo, List<ServerName> servers)` Used to assign a single region to a random server.
`ServerName`	FavoredNodeLoadBalancer.`randomAssignment(HRegionInfo regionInfo, List<ServerName> servers)`
`ServerName`	BaseLoadBalancer.`randomAssignment(HRegionInfo regionInfo, List<ServerName> servers)` Used to assign a single region to a random server.
`private ServerName[]`	FavoredNodeAssignmentHelper.`singleRackCase(HRegionInfo regionInfo, ServerName primaryRS, String primaryRack)`

Methods in org.apache.hadoop.hbase.master.balancer that return types with arguments of type ServerName
Modifier and Type	Method and Description
`protected Map<ServerName,List<HRegionInfo>>`	BaseLoadBalancer.`assignMasterRegions(Collection<HRegionInfo> regions, List<ServerName> servers)` Assign the regions that should be on master regionserver.
`Map<HRegionInfo,List<ServerName>>`	FavoredNodesPlan.`getAssignmentMap()`
`(package private) Map<ServerName,List<HRegionInfo>>`	ClusterLoadState.`getClusterState()`
`List<ServerName>`	FavoredNodeLoadBalancer.`getFavoredNodes(HRegionInfo regionInfo)`
`List<ServerName>`	FavoredNodesPlan.`getFavoredNodes(HRegionInfo region)`
`protected Map<ServerName,List<HRegionInfo>>`	BaseLoadBalancer.`getRegionAssignmentsByServer(Collection<HRegionInfo> regions)`
`private List<ServerName>`	FavoredNodeAssignmentHelper.`getServersFromRack(String rack)`
`protected List<ServerName>`	RegionLocationFinder.`getTopBlockLocations(HRegionInfo region)`
`Map<HRegionInfo,ServerName>`	BaseLoadBalancer.`immediateAssignment(List<HRegionInfo> regions, List<ServerName> servers)` Generates an immediate assignment plan to be used by a new master for regions in transition that do not have an already known destination.
`protected List<ServerName>`	RegionLocationFinder.`mapHostNameToServerName(List<String> hosts)` Map hostname to ServerName, The output ServerName list will have the same order as input hosts.
`private Map<ServerName,Set<HRegionInfo>>`	FavoredNodeAssignmentHelper.`mapRSToPrimaries(Map<HRegionInfo,ServerName> primaryRSMap)`
`Map<ServerName,List<HRegionInfo>>`	BaseLoadBalancer.`retainAssignment(Map<HRegionInfo,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<HRegionInfo>>`	FavoredNodeLoadBalancer.`roundRobinAssignment(List<HRegionInfo> regions, List<ServerName> servers)`
`Map<ServerName,List<HRegionInfo>>`	BaseLoadBalancer.`roundRobinAssignment(List<HRegionInfo> regions, List<ServerName> servers)` Generates a bulk assignment plan to be used on cluster startup using a simple round-robin assignment.
`private Pair<Map<ServerName,List<HRegionInfo>>,List<HRegionInfo>>`	FavoredNodeLoadBalancer.`segregateRegionsAndAssignRegionsWithFavoredNodes(List<HRegionInfo> regions, List<ServerName> availableServers)`

Methods in org.apache.hadoop.hbase.master.balancer with parameters of type ServerName
Modifier and Type	Method and Description
`private void`	SimpleLoadBalancer.`addRegionPlan(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`	FavoredNodeLoadBalancer.`addRegionToMap(Map<ServerName,List<HRegionInfo>> assignmentMapForFavoredNodes, HRegionInfo region, ServerName host)`
`private void`	FavoredNodeLoadBalancer.`assignRegionToAvailableFavoredNode(Map<ServerName,List<HRegionInfo>> assignmentMapForFavoredNodes, HRegionInfo region, ServerName primaryHost, ServerName secondaryHost, ServerName tertiaryHost)`
`private ServerName`	FavoredNodeLoadBalancer.`availableServersContains(List<ServerName> servers, ServerName favoredNode)`
`(package private) void`	BaseLoadBalancer.Cluster.`doAssignRegion(HRegionInfo regionInfo, ServerName serverName)`
`static FavoredNodesPlan.Position`	FavoredNodesPlan.`getFavoredServerPosition(List<ServerName> favoredNodes, ServerName server)` Return the position of the server in the favoredNodes list.
`String`	BaseLoadBalancer.DefaultRackManager.`getRack(ServerName server)`
`private ServerName[]`	FavoredNodeAssignmentHelper.`multiRackCase(HRegionInfo regionInfo, ServerName primaryRS, String primaryRack)`
`private ServerName[]`	FavoredNodeAssignmentHelper.`multiRackCaseWithRestrictions(Map<ServerName,Set<HRegionInfo>> serverToPrimaries, Map<HRegionInfo,ServerName[]> secondaryAndTertiaryMap, String primaryRack, ServerName primaryRS, HRegionInfo regionInfo)`
`void`	BaseLoadBalancer.`regionOnline(HRegionInfo regionInfo, ServerName sn)`
`private ServerName[]`	FavoredNodeAssignmentHelper.`singleRackCase(HRegionInfo regionInfo, ServerName primaryRS, String primaryRack)`
`(package private) boolean`	BaseLoadBalancer.Cluster.`wouldLowerAvailability(HRegionInfo regionInfo, ServerName serverName)` Return true if the placement of region on server would lower the availability of the region in question

Method parameters in org.apache.hadoop.hbase.master.balancer with type arguments of type ServerName
Modifier and Type	Method and Description
`private void`	FavoredNodeLoadBalancer.`addRegionToMap(Map<ServerName,List<HRegionInfo>> assignmentMapForFavoredNodes, HRegionInfo region, ServerName host)`
`protected Map<ServerName,List<HRegionInfo>>`	BaseLoadBalancer.`assignMasterRegions(Collection<HRegionInfo> regions, List<ServerName> servers)` Assign the regions that should be on master regionserver.
`private void`	FavoredNodeLoadBalancer.`assignRegionToAvailableFavoredNode(Map<ServerName,List<HRegionInfo>> assignmentMapForFavoredNodes, HRegionInfo region, ServerName primaryHost, ServerName secondaryHost, ServerName tertiaryHost)`
`private void`	FavoredNodeLoadBalancer.`assignSecondaryAndTertiaryNodesForRegion(FavoredNodeAssignmentHelper assignmentHelper, List<HRegionInfo> regions, Map<HRegionInfo,ServerName> primaryRSMap)`
`private ServerName`	FavoredNodeLoadBalancer.`availableServersContains(List<ServerName> servers, ServerName favoredNode)`
`List<RegionPlan>`	FavoredNodeLoadBalancer.`balanceCluster(Map<ServerName,List<HRegionInfo>> clusterState)`
`List<RegionPlan>`	StochasticLoadBalancer.`balanceCluster(Map<ServerName,List<HRegionInfo>> clusterState)` Given the cluster state this will try and approach an optimal balance.
`List<RegionPlan>`	SimpleLoadBalancer.`balanceCluster(Map<ServerName,List<HRegionInfo>> clusterMap)` Generate a global load balancing plan according to the specified map of server information to the most loaded regions of each server.
`protected List<RegionPlan>`	BaseLoadBalancer.`balanceMasterRegions(Map<ServerName,List<HRegionInfo>> clusterMap)` Balance the regions that should be on master regionserver.
`protected BaseLoadBalancer.Cluster`	BaseLoadBalancer.`createCluster(List<ServerName> servers, Collection<HRegionInfo> regions)`
`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 ServerName`	FavoredNodeAssignmentHelper.`getOneRandomServer(String rack, Set<ServerName> skipServerSet)`
`Map<HRegionInfo,ServerName>`	BaseLoadBalancer.`immediateAssignment(List<HRegionInfo> regions, List<ServerName> servers)` Generates an immediate assignment plan to be used by a new master for regions in transition that do not have an already known destination.
`(package private) static Put`	FavoredNodeAssignmentHelper.`makePutFromRegionInfo(HRegionInfo regionInfo, List<ServerName> favoredNodeList)` Generates and returns a Put containing the region info for the catalog table and the servers
`private Map<ServerName,Set<HRegionInfo>>`	FavoredNodeAssignmentHelper.`mapRSToPrimaries(Map<HRegionInfo,ServerName> primaryRSMap)`
`private ServerName[]`	FavoredNodeAssignmentHelper.`multiRackCaseWithRestrictions(Map<ServerName,Set<HRegionInfo>> serverToPrimaries, Map<HRegionInfo,ServerName[]> secondaryAndTertiaryMap, String primaryRack, ServerName primaryRS, HRegionInfo regionInfo)`
`(package private) void`	FavoredNodeAssignmentHelper.`placePrimaryRSAsRoundRobin(Map<ServerName,List<HRegionInfo>> assignmentMap, Map<HRegionInfo,ServerName> primaryRSMap, List<HRegionInfo> regions)`
`(package private) void`	FavoredNodeAssignmentHelper.`placePrimaryRSAsRoundRobin(Map<ServerName,List<HRegionInfo>> assignmentMap, Map<HRegionInfo,ServerName> primaryRSMap, List<HRegionInfo> regions)`
`(package private) Map<HRegionInfo,ServerName[]>`	FavoredNodeAssignmentHelper.`placeSecondaryAndTertiaryRS(Map<HRegionInfo,ServerName> primaryRSMap)`
`Map<HRegionInfo,ServerName[]>`	FavoredNodeAssignmentHelper.`placeSecondaryAndTertiaryWithRestrictions(Map<HRegionInfo,ServerName> primaryRSMap)` For regions that share the primary, avoid placing the secondary and tertiary on a same RS.
`private ServerName`	BaseLoadBalancer.`randomAssignment(BaseLoadBalancer.Cluster cluster, HRegionInfo regionInfo, List<ServerName> servers)` Used to assign a single region to a random server.
`ServerName`	FavoredNodeLoadBalancer.`randomAssignment(HRegionInfo regionInfo, List<ServerName> servers)`
`ServerName`	BaseLoadBalancer.`randomAssignment(HRegionInfo regionInfo, List<ServerName> servers)` Used to assign a single region to a random server.
`Map<ServerName,List<HRegionInfo>>`	BaseLoadBalancer.`retainAssignment(Map<HRegionInfo,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<HRegionInfo>>`	BaseLoadBalancer.`retainAssignment(Map<HRegionInfo,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.
`private void`	BaseLoadBalancer.`roundRobinAssignment(BaseLoadBalancer.Cluster cluster, List<HRegionInfo> regions, List<HRegionInfo> unassignedRegions, List<ServerName> servers, Map<ServerName,List<HRegionInfo>> assignments)` Round robin a list of regions to a list of servers
`private void`	BaseLoadBalancer.`roundRobinAssignment(BaseLoadBalancer.Cluster cluster, List<HRegionInfo> regions, List<HRegionInfo> unassignedRegions, List<ServerName> servers, Map<ServerName,List<HRegionInfo>> assignments)` Round robin a list of regions to a list of servers
`Map<ServerName,List<HRegionInfo>>`	FavoredNodeLoadBalancer.`roundRobinAssignment(List<HRegionInfo> regions, List<ServerName> servers)`
`Map<ServerName,List<HRegionInfo>>`	BaseLoadBalancer.`roundRobinAssignment(List<HRegionInfo> regions, List<ServerName> servers)` Generates a bulk assignment plan to be used on cluster startup using a simple round-robin assignment.
`private void`	FavoredNodeLoadBalancer.`roundRobinAssignmentImpl(FavoredNodeAssignmentHelper assignmentHelper, Map<ServerName,List<HRegionInfo>> assignmentMap, List<HRegionInfo> regions, List<ServerName> servers)`
`private void`	FavoredNodeLoadBalancer.`roundRobinAssignmentImpl(FavoredNodeAssignmentHelper assignmentHelper, Map<ServerName,List<HRegionInfo>> assignmentMap, List<HRegionInfo> regions, List<ServerName> servers)`
`private Pair<Map<ServerName,List<HRegionInfo>>,List<HRegionInfo>>`	FavoredNodeLoadBalancer.`segregateRegionsAndAssignRegionsWithFavoredNodes(List<HRegionInfo> regions, List<ServerName> availableServers)`
`void`	FavoredNodesPlan.`updateAssignmentPlan(HRegionInfo region, List<ServerName> servers)` Add an assignment to the plan
`void`	FavoredNodesPlan.`updateFavoredNodesMap(HRegionInfo region, List<ServerName> servers)` Add an assignment to the plan
`static void`	FavoredNodeAssignmentHelper.`updateMetaWithFavoredNodesInfo(Map<HRegionInfo,List<ServerName>> regionToFavoredNodes, org.apache.hadoop.conf.Configuration conf)` Update meta table with favored nodes info
`static void`	FavoredNodeAssignmentHelper.`updateMetaWithFavoredNodesInfo(Map<HRegionInfo,List<ServerName>> regionToFavoredNodes, Connection connection)` Update meta table with favored nodes info

Constructors in org.apache.hadoop.hbase.master.balancer with parameters of type ServerName
Constructor and Description
`ServerAndLoad(ServerName sn, int load)`

Constructor parameters in org.apache.hadoop.hbase.master.balancer with type arguments of type ServerName
Constructor and Description
`BaseLoadBalancer.Cluster(Collection<HRegionInfo> unassignedRegions, Map<ServerName,List<HRegionInfo>> clusterState, Map<String,Deque<RegionLoad>> loads, RegionLocationFinder regionFinder, RackManager rackManager)`
`BaseLoadBalancer.Cluster(Map<ServerName,List<HRegionInfo>> clusterState, Map<String,Deque<RegionLoad>> loads, RegionLocationFinder regionFinder, RackManager rackManager)`
`ClusterLoadState(Map<ServerName,List<HRegionInfo>> clusterState)`
`FavoredNodeAssignmentHelper(List<ServerName> servers, org.apache.hadoop.conf.Configuration conf)`
`FavoredNodeAssignmentHelper(List<ServerName> servers, RackManager rackManager)`

Uses of ServerName in org.apache.hadoop.hbase.master.handler

Methods in org.apache.hadoop.hbase.master.handler that return types with arguments of type ServerName
Modifier and Type	Method and Description
`private Map<HRegionInfo,ServerName>`	EnableTableHandler.`regionsToAssignWithServerName(List<Pair<HRegionInfo,ServerName>> regionsInMeta)`

Methods in org.apache.hadoop.hbase.master.handler with parameters of type ServerName
Modifier and Type	Method and Description
`private RegionLoad`	DispatchMergingRegionHandler.`getRegionLoad(ServerName sn, HRegionInfo hri)`

Method parameters in org.apache.hadoop.hbase.master.handler with type arguments of type ServerName
Modifier and Type	Method and Description
`private Map<HRegionInfo,ServerName>`	EnableTableHandler.`regionsToAssignWithServerName(List<Pair<HRegionInfo,ServerName>> regionsInMeta)`

Uses of ServerName in org.apache.hadoop.hbase.master.procedure

Fields in org.apache.hadoop.hbase.master.procedure declared as ServerName
Modifier and Type	Field and Description
`private ServerName`	ServerCrashProcedure.`serverName` Name of the crashed server to process.

Fields in org.apache.hadoop.hbase.master.procedure with type parameters of type ServerName
Modifier and Type	Field and Description
`private MasterProcedureScheduler.FairQueue<ServerName>`	MasterProcedureScheduler.`serverRunQueue`
`private MasterProcedureScheduler.Queue<ServerName>`	MasterProcedureScheduler.ProcedureEvent.`waitingServers`

Methods in org.apache.hadoop.hbase.master.procedure that return ServerName
Modifier and Type	Method and Description
`ServerName`	ServerProcedureInterface.`getServerName()`
`ServerName`	ServerCrashProcedure.`getServerName()`
`private static ServerName`	MasterProcedureScheduler.`getServerName(Procedure proc)`

Methods in org.apache.hadoop.hbase.master.procedure that return types with arguments of type ServerName
Modifier and Type	Method and Description
`private MasterProcedureScheduler.Queue<ServerName>`	MasterProcedureScheduler.ProcedureEvent.`popWaitingServer()`
`private static Map<HRegionInfo,ServerName>`	EnableTableProcedure.`regionsToAssignWithServerName(MasterProcedureEnv env, List<Pair<HRegionInfo,ServerName>> regionsInMeta)`

Methods in org.apache.hadoop.hbase.master.procedure with parameters of type ServerName
Modifier and Type	Method and Description
`private MasterProcedureScheduler.ServerQueue`	MasterProcedureScheduler.`getServerQueue(ServerName serverName)`
`private MasterProcedureScheduler.ServerQueue`	MasterProcedureScheduler.`getServerQueueWithLock(ServerName serverName)`
`void`	MasterProcedureScheduler.`releaseServerExclusiveLock(Procedure procedure, ServerName serverName)` Release the exclusive lock
`void`	MasterProcedureScheduler.`releaseServerSharedLock(Procedure procedure, ServerName serverName)` Release the shared lock taken
`private void`	MasterProcedureScheduler.`removeServerQueue(ServerName serverName)`
`private void`	MasterProcedureScheduler.`suspendServerQueue(MasterProcedureScheduler.ProcedureEvent event, ServerName serverName)`
`boolean`	MasterProcedureScheduler.`tryAcquireServerExclusiveLock(Procedure procedure, ServerName serverName)` Try to acquire the exclusive lock on the specified server.
`boolean`	MasterProcedureScheduler.`tryAcquireServerSharedLock(Procedure procedure, ServerName serverName)` Try to acquire the shared lock on the specified server.

Method parameters in org.apache.hadoop.hbase.master.procedure with type arguments of type ServerName
Modifier and Type	Method and Description
`private static Map<HRegionInfo,ServerName>`	EnableTableProcedure.`regionsToAssignWithServerName(MasterProcedureEnv env, List<Pair<HRegionInfo,ServerName>> regionsInMeta)`
`private void`	MasterProcedureScheduler.ProcedureEvent.`suspendServerQueue(MasterProcedureScheduler.Queue<ServerName> queue)`

Constructors in org.apache.hadoop.hbase.master.procedure with parameters of type ServerName
Constructor and Description
`MasterProcedureScheduler.ServerQueue(ServerName serverName)`
`ServerCrashProcedure(MasterProcedureEnv env, ServerName serverName, boolean shouldSplitWal, boolean carryingMeta)` Call this constructor queuing up a Procedure.

Uses of ServerName in org.apache.hadoop.hbase.master.snapshot

Method parameters in org.apache.hadoop.hbase.master.snapshot with type arguments of type ServerName
Modifier and Type	Method and Description
`protected void`	EnabledTableSnapshotHandler.`snapshotRegions(List<Pair<HRegionInfo,ServerName>> regions)` This method kicks off a snapshot procedure.
`void`	DisabledTableSnapshotHandler.`snapshotRegions(List<Pair<HRegionInfo,ServerName>> regionsAndLocations)`
`protected abstract void`	TakeSnapshotHandler.`snapshotRegions(List<Pair<HRegionInfo,ServerName>> regions)` Snapshot the specified regions

Uses of ServerName in org.apache.hadoop.hbase.regionserver

Fields in org.apache.hadoop.hbase.regionserver declared as ServerName
Modifier and Type	Field and Description
`protected ServerName`	HRegionServer.`serverName` The server name the Master sees us as.
`private ServerName`	HRegionServer.MovedRegionInfo.`serverName`

Methods in org.apache.hadoop.hbase.regionserver that return 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`	HRegionServer.`getServerName()`
`ServerName`	HRegionServer.MovedRegionInfo.`getServerName()`

Methods in org.apache.hadoop.hbase.regionserver with parameters of type ServerName
Modifier and Type	Method and Description
`Put`	SplitTransactionImpl.`addLocation(Put p, ServerName sn, long openSeqNum)`
`Put`	RegionMergeTransactionImpl.`addLocation(Put p, ServerName sn, long openSeqNum)`
`protected void`	HRegionServer.`addToMovedRegions(String encodedName, ServerName destination, long closeSeqNum)`
`protected boolean`	HRegionServer.`closeRegion(String encodedName, boolean abort, CloseRegionCoordination.CloseRegionDetails crd, ServerName sn)` Close asynchronously a region, can be called from the master or internally by the regionserver when stopping.
`private void`	RegionMergeTransactionImpl.`mergeRegionsAndPutMetaEntries(HConnection hConnection, HRegionInfo mergedRegion, HRegionInfo regionA, HRegionInfo regionB, ServerName serverName, List<Mutation> metaEntries, int regionReplication)`
`private void`	SplitTransactionImpl.`offlineParentInMetaAndputMetaEntries(HConnection hConnection, HRegionInfo parent, HRegionInfo splitA, HRegionInfo splitB, ServerName serverName, List<Mutation> metaEntries, int regionReplication)`
`void`	RegionMergeTransactionImpl.`prepareMutationsForMerge(HRegionInfo mergedRegion, HRegionInfo regionA, HRegionInfo regionB, ServerName serverName, List<Mutation> mutations, int regionReplication)`
`boolean`	OnlineRegions.`removeFromOnlineRegions(Region r, ServerName destination)` This method removes Region corresponding to hri from the Map of onlineRegions.
`boolean`	HRegionServer.`removeFromOnlineRegions(Region r, ServerName destination)`

Constructors in org.apache.hadoop.hbase.regionserver with parameters of type ServerName
Constructor and Description
`HRegionServer.MovedRegionInfo(ServerName serverName, long closeSeqNum)`
`ScannerIdGenerator(ServerName serverName)`

Uses of ServerName in org.apache.hadoop.hbase.regionserver.handler

Fields in org.apache.hadoop.hbase.regionserver.handler declared as ServerName
Modifier and Type	Field and Description
`private ServerName`	CloseRegionHandler.`destination`
`private ServerName`	WALSplitterHandler.`serverName`

Constructors in org.apache.hadoop.hbase.regionserver.handler with parameters of type ServerName
Constructor and Description
`CloseRegionHandler(Server server, RegionServerServices rsServices, HRegionInfo regionInfo, boolean abort, CloseRegionCoordination closeRegionCoordination, CloseRegionCoordination.CloseRegionDetails crd, EventType eventType, ServerName destination)`
`CloseRegionHandler(Server server, RegionServerServices rsServices, HRegionInfo regionInfo, boolean abort, CloseRegionCoordination closeRegionCoordination, CloseRegionCoordination.CloseRegionDetails crd, ServerName destination)`

Uses of ServerName in org.apache.hadoop.hbase.replication

Fields in org.apache.hadoop.hbase.replication with type parameters of type ServerName
Modifier and Type	Field and Description
`private List<ServerName>`	HBaseReplicationEndpoint.`regionServers`

Methods in org.apache.hadoop.hbase.replication that return types with arguments of type ServerName
Modifier and Type	Method and Description
`protected static List<ServerName>`	HBaseReplicationEndpoint.`fetchSlavesAddresses(ZooKeeperWatcher zkw)` Get the list of all the region servers from the specified peer
`List<ServerName>`	HBaseReplicationEndpoint.`getRegionServers()` Get a list of all the addresses of all the region servers for this peer cluster

Method parameters in org.apache.hadoop.hbase.replication with type arguments of type ServerName
Modifier and Type	Method and Description
`void`	HBaseReplicationEndpoint.`setRegionServers(List<ServerName> regionServers)` Set the list of region servers for that peer

Uses of ServerName in org.apache.hadoop.hbase.replication.regionserver

Fields in org.apache.hadoop.hbase.replication.regionserver declared as ServerName
Modifier and Type	Field and Description
`private ServerName`	ReplicationSinkManager.SinkPeer.`serverName`

Fields in org.apache.hadoop.hbase.replication.regionserver with type parameters of type ServerName
Modifier and Type	Field and Description
`private Map<ServerName,Integer>`	ReplicationSinkManager.`badReportCounts`
`private List<ServerName>`	ReplicationSinkManager.`sinks`

Methods in org.apache.hadoop.hbase.replication.regionserver that return ServerName
Modifier and Type	Method and Description
`ServerName`	ReplicationSyncUp.DummyServer.`getServerName()`
`(package private) ServerName`	ReplicationSinkManager.SinkPeer.`getServerName()`

Methods in org.apache.hadoop.hbase.replication.regionserver that return types with arguments of type ServerName
Modifier and Type	Method and Description
`protected List<ServerName>`	ReplicationSinkManager.`getSinksForTesting()`

Constructors in org.apache.hadoop.hbase.replication.regionserver with parameters of type ServerName
Constructor and Description
`ReplicationSinkManager.SinkPeer(ServerName serverName, org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface regionServer)`

Uses of ServerName in org.apache.hadoop.hbase.security.access

Methods in org.apache.hadoop.hbase.security.access with parameters of type ServerName
Modifier and Type	Method and Description
`void`	AccessController.`preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer)`

Uses of ServerName in org.apache.hadoop.hbase.tmpl.master

Fields in org.apache.hadoop.hbase.tmpl.master declared as ServerName
Modifier and Type	Field and Description
`private ServerName`	MasterStatusTmpl.ImplData.`m_metaLocation`
`protected ServerName`	MasterStatusTmpl.`metaLocation`
`private ServerName`	MasterStatusTmplImpl.`metaLocation`

Fields in org.apache.hadoop.hbase.tmpl.master with type parameters of type ServerName
Modifier and Type	Field and Description
`protected Set<ServerName>`	MasterStatusTmpl.`deadServers`
`private Set<ServerName>`	MasterStatusTmplImpl.`deadServers`
`private Set<ServerName>`	MasterStatusTmpl.ImplData.`m_deadServers`
`private List<ServerName>`	MasterStatusTmpl.ImplData.`m_servers`
`private List<ServerName>`	RegionServerListTmpl.ImplData.`m_servers`
`protected List<ServerName>`	MasterStatusTmpl.`servers`
`private List<ServerName>`	MasterStatusTmplImpl.`servers`
`private List<ServerName>`	RegionServerListTmplImpl.`servers`
`protected List<ServerName>`	RegionServerListTmpl.`servers`

Methods in org.apache.hadoop.hbase.tmpl.master that return ServerName
Modifier and Type	Method and Description
`ServerName`	MasterStatusTmpl.ImplData.`getMetaLocation()`

Methods in org.apache.hadoop.hbase.tmpl.master that return types with arguments of type ServerName
Modifier and Type	Method and Description
`Set<ServerName>`	MasterStatusTmpl.ImplData.`getDeadServers()`
`List<ServerName>`	MasterStatusTmpl.ImplData.`getServers()`
`List<ServerName>`	RegionServerListTmpl.ImplData.`getServers()`

Methods in org.apache.hadoop.hbase.tmpl.master with parameters of type ServerName
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, ServerLoad serverLoad)`
`private void`	RegionServerListTmplImpl.`__jamon_innerUnit__storeStats(Writer jamonWriter, ServerName[] serverNames)`
`MasterStatusTmpl`	MasterStatusTmpl.`setMetaLocation(ServerName p_metaLocation)`
`void`	MasterStatusTmpl.ImplData.`setMetaLocation(ServerName metaLocation)`

Method parameters in org.apache.hadoop.hbase.tmpl.master with type arguments of type ServerName
Modifier and Type	Method and Description
`MasterStatusTmpl`	MasterStatusTmpl.`setDeadServers(Set<ServerName> p_deadServers)`
`void`	MasterStatusTmpl.ImplData.`setDeadServers(Set<ServerName> deadServers)`
`MasterStatusTmpl`	MasterStatusTmpl.`setServers(List<ServerName> p_servers)`
`void`	MasterStatusTmpl.ImplData.`setServers(List<ServerName> servers)`
`RegionServerListTmpl`	RegionServerListTmpl.`setServers(List<ServerName> p_servers)`
`void`	RegionServerListTmpl.ImplData.`setServers(List<ServerName> servers)`

Uses of ServerName in org.apache.hadoop.hbase.util

Fields in org.apache.hadoop.hbase.util declared as ServerName
Modifier and Type	Field and Description
`(package private) ServerName`	HBaseFsck.OnlineEntry.`hsa`
`(package private) ServerName`	HBaseFsck.MetaEntry.`regionServer`
`private ServerName`	HBaseFsck.WorkItemRegion.`rsinfo`

Fields in org.apache.hadoop.hbase.util with type parameters of type ServerName
Modifier and Type	Field and Description
`(package private) TreeSet<ServerName>`	HBaseFsck.TableInfo.`deployedOn`
`private List<ServerName>`	HBaseFsck.HbckInfo.`deployedOn`

Methods in org.apache.hadoop.hbase.util that return ServerName
Modifier and Type	Method and Description
`private ServerName`	HBaseFsck.`getMetaRegionServerName(int replicaId)`

Methods in org.apache.hadoop.hbase.util with parameters of type ServerName
Modifier and Type	Method and Description
`void`	HBaseFsck.HbckInfo.`addServer(HRegionInfo hri, ServerName server)`
`void`	HBaseFsck.TableInfo.`addServer(ServerName server)`
`static void`	HBaseFsckRepair.`closeRegionSilentlyAndWait(HConnection connection, ServerName server, HRegionInfo region)` Contacts a region server and waits up to hbase.hbck.close.timeout ms (default 120s) to close the region.

Method parameters in org.apache.hadoop.hbase.util with type arguments of type ServerName
Modifier and Type	Method and Description
`static void`	HBaseFsckRepair.`fixMetaHoleOnlineAndAddReplicas(org.apache.hadoop.conf.Configuration conf, HRegionInfo hri, Collection<ServerName> servers, int numReplicas)` Puts the specified HRegionInfo into META with replica related columns
`static void`	HBaseFsckRepair.`fixMultiAssignment(HConnection connection, HRegionInfo 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.

Constructors in org.apache.hadoop.hbase.util with parameters of type ServerName
Constructor and Description
`HBaseFsck.MetaEntry(HRegionInfo rinfo, ServerName regionServer, long modTime)`
`HBaseFsck.MetaEntry(HRegionInfo rinfo, ServerName regionServer, long modTime, HRegionInfo splitA, HRegionInfo splitB)`
`HBaseFsck.WorkItemRegion(HBaseFsck hbck, ServerName info, HBaseFsck.ErrorReporter errors, HConnection connection)`

Uses of ServerName in org.apache.hadoop.hbase.wal

Methods in org.apache.hadoop.hbase.wal that return ServerName
Modifier and Type	Method and Description
`static ServerName`	DefaultWALProvider.`getServerNameFromWALDirectoryName(org.apache.hadoop.conf.Configuration conf, String path)` Pulls a ServerName out of a Path generated according to our layout rules.
`static ServerName`	DefaultWALProvider.`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>/...

Uses of ServerName in org.apache.hadoop.hbase.zookeeper

Fields in org.apache.hadoop.hbase.zookeeper with type parameters of type ServerName
Modifier and Type	Field and Description
`private NavigableSet<ServerName>`	DrainingServerTracker.`drainingServers`
`private NavigableMap<ServerName,org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionServerInfo>`	RegionServerTracker.`regionServers`

Methods in org.apache.hadoop.hbase.zookeeper that return ServerName
Modifier and Type	Method and Description
`ServerName`	MetaTableLocator.`blockUntilAvailable(ZooKeeperWatcher zkw, int replicaId, long timeout)` Wait until the meta region is available and is not in transition.
`ServerName`	MetaTableLocator.`blockUntilAvailable(ZooKeeperWatcher 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(ZooKeeperWatcher zkw)` Get master address.
`ServerName`	MetaTableLocator.`getMetaRegionLocation(ZooKeeperWatcher zkw)` Gets the meta region location, if available.
`ServerName`	MetaTableLocator.`getMetaRegionLocation(ZooKeeperWatcher zkw, int replicaId)` Gets the meta region location, if available.
`static ServerName[]`	ZKServerTool.`readZKNodes(org.apache.hadoop.conf.Configuration conf)`
`ServerName`	MetaTableLocator.`waitMetaRegionLocation(ZooKeeperWatcher 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(ZooKeeperWatcher zkw, long timeout)` Gets the meta region location, if available, and waits for up to the specified timeout if not immediately available.

Methods in org.apache.hadoop.hbase.zookeeper that return types with arguments of type ServerName
Modifier and Type	Method and Description
`List<ServerName>`	MetaTableLocator.`blockUntilAvailable(ZooKeeperWatcher zkw, long timeout, org.apache.hadoop.conf.Configuration conf)` Wait until the primary meta region is available.
`List<Pair<HRegionInfo,ServerName>>`	MetaTableLocator.`getMetaRegionsAndLocations(ZooKeeperWatcher zkw)`
`List<Pair<HRegionInfo,ServerName>>`	MetaTableLocator.`getMetaRegionsAndLocations(ZooKeeperWatcher zkw, int replicaId)`
`List<ServerName>`	RegionServerTracker.`getOnlineServers()` Gets the online servers.

Methods in org.apache.hadoop.hbase.zookeeper with parameters of type ServerName
Modifier and Type	Method and Description
`static void`	ZKAssign.`asyncCreateNodeOffline(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName, org.apache.zookeeper.AsyncCallback.StringCallback cb, Object ctx)` Creates an unassigned node in the OFFLINE state for the specified region.
`static int`	ZKAssign.`confirmNodeOpening(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName, int expectedVersion)` Confirm an existing unassigned node for the specified region which is currently in the OPENING state to be still in the OPENING state on the specified server.
`static int`	ZKAssign.`createNodeClosing(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName)` Creates a new unassigned node in the CLOSING state for the specified region.
`static void`	ZKAssign.`createNodeOffline(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName)` Creates a new unassigned node in the OFFLINE state for the specified region.
`static void`	ZKAssign.`createNodeOffline(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName, EventType event)`
`static int`	ZKAssign.`createOrForceNodeOffline(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName)` Creates or force updates an unassigned node to the OFFLINE state for the specified region.
`static boolean`	ZKAssign.`deleteClosedNode(ZooKeeperWatcher zkw, String encodedRegionName, ServerName sn)` Deletes an existing unassigned node that is in the CLOSED state for the specified region.
`static boolean`	ZKAssign.`deleteClosingNode(ZooKeeperWatcher zkw, HRegionInfo region, ServerName sn)` Deletes an existing unassigned node that is in the CLOSING state for the specified region.
`static boolean`	ZKAssign.`deleteNode(ZooKeeperWatcher zkw, String encodedRegionName, EventType expectedState, ServerName sn)` Deletes an existing unassigned node that is in the specified state for the specified region.
`static boolean`	ZKAssign.`deleteNode(ZooKeeperWatcher zkw, String encodedRegionName, EventType expectedState, ServerName serverName, int expectedVersion)` Deletes an existing unassigned node that is in the specified state for the specified region.
`static boolean`	ZKAssign.`deleteOfflineNode(ZooKeeperWatcher zkw, String encodedRegionName, ServerName sn)` Deletes an existing unassigned node that is in the OFFLINE state for the specified region.
`static boolean`	ZKAssign.`deleteOpenedNode(ZooKeeperWatcher zkw, String encodedRegionName, ServerName sn)` Deletes an existing unassigned node that is in the OPENED state for the specified region.
`int`	MasterAddressTracker.`getBackupMasterInfoPort(ServerName sn)` Get the info port of the backup master if it is available.
`private static org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	MetaTableLocator.`getCachedConnection(HConnection hConnection, ServerName sn)`
`org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionServerInfo`	RegionServerTracker.`getRegionServerInfo(ServerName sn)`
`private void`	DrainingServerTracker.`remove(ServerName sn)`
`private void`	RegionServerTracker.`remove(ServerName sn)`
`static boolean`	MasterAddressTracker.`setMasterAddress(ZooKeeperWatcher 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(ZooKeeperWatcher 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(ZooKeeperWatcher 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)`
`static int`	ZKAssign.`transitionNode(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName, EventType beginState, EventType endState, int expectedVersion)` Method that actually performs unassigned node transitions.
`static int`	ZKAssign.`transitionNode(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName, EventType beginState, EventType endState, int expectedVersion, byte[] payload)`
`static int`	ZKAssign.`transitionNodeClosed(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName, int expectedVersion)` Transitions an existing unassigned node for the specified region which is currently in the CLOSING state to be in the CLOSED state.
`static int`	ZKAssign.`transitionNodeOpened(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName, int expectedVersion)` Transitions an existing unassigned node for the specified region which is currently in the OPENING state to be in the OPENED state.
`static int`	ZKAssign.`transitionNodeOpening(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName)` Transitions an existing unassigned node for the specified region which is currently in the OFFLINE state to be in the OPENING state.
`static int`	ZKAssign.`transitionNodeOpening(ZooKeeperWatcher zkw, HRegionInfo region, ServerName serverName, EventType beginState)`
`private boolean`	MetaTableLocator.`verifyRegionLocation(Connection connection, org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface hostingServer, ServerName address, byte[] regionName)` Verify we can connect to `hostingServer` and that its carrying `regionName`.

Method parameters in org.apache.hadoop.hbase.zookeeper with type arguments of type ServerName
Modifier and Type	Method and Description
`private List<HRegionInfo>`	MetaTableLocator.`getListOfHRegionInfos(List<Pair<HRegionInfo,ServerName>> pairs)`

Uses of Classorg.apache.hadoop.hbase.ServerName

Uses of ServerName in org.apache.hadoop.hbase

Uses of ServerName in org.apache.hadoop.hbase.client

Uses of ServerName in org.apache.hadoop.hbase.client.backoff

Uses of ServerName in org.apache.hadoop.hbase.coordination

Uses of ServerName in org.apache.hadoop.hbase.coprocessor

Uses of ServerName in org.apache.hadoop.hbase.exceptions

Uses of ServerName in org.apache.hadoop.hbase.ipc

Uses of ServerName in org.apache.hadoop.hbase.master

Uses of ServerName in org.apache.hadoop.hbase.master.balancer

Uses of ServerName in org.apache.hadoop.hbase.master.handler

Uses of ServerName in org.apache.hadoop.hbase.master.procedure

Uses of ServerName in org.apache.hadoop.hbase.master.snapshot

Uses of ServerName in org.apache.hadoop.hbase.regionserver

Uses of ServerName in org.apache.hadoop.hbase.regionserver.handler

Uses of ServerName in org.apache.hadoop.hbase.replication

Uses of ServerName in org.apache.hadoop.hbase.replication.regionserver

Uses of ServerName in org.apache.hadoop.hbase.security.access

Uses of ServerName in org.apache.hadoop.hbase.tmpl.master

Uses of ServerName in org.apache.hadoop.hbase.util

Uses of ServerName in org.apache.hadoop.hbase.wal

Uses of ServerName in org.apache.hadoop.hbase.zookeeper

Uses of Class
org.apache.hadoop.hbase.ServerName