ConnectionImplementation (Apache HBase 2.5.0 API)

java.lang.Object
- org.apache.hadoop.hbase.client.ConnectionImplementation

All Implemented Interfaces:

Closeable, AutoCloseable, Abortable, ClusterConnection, Connection

Direct Known Subclasses:

ConnectionUtils.MasterlessConnection, ServerConnectionUtils.ShortCircuitingClusterConnection
```
@InterfaceAudience.Private
public class ConnectionImplementation
extends Object
implements ClusterConnection, Closeable
```
Main implementation of Connection and ClusterConnection interfaces. Encapsulates connection to zookeeper and regionservers.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`ConnectionImplementation.LocalConnectionClosedException` Like `ConnectionClosedException` but thrown from the checkClosed call which looks at the local this.closed flag.
`(package private) static class`	`ConnectionImplementation.MasterServiceState` State of the MasterService connection/setup.
`private class`	`ConnectionImplementation.MasterServiceStubMaker` Class to make a MasterServiceStubMaker stub.
`(package private) static class`	`ConnectionImplementation.ServerErrorTracker` The record of errors for servers.

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`aborted`
`private String`	`alternateBufferedMutatorClassName` Allow setting an alternate BufferedMutator implementation via config.
`private AsyncProcess`	`asyncProcess`
`private ClientBackoffPolicy`	`backoffPolicy`
`private ThreadPoolExecutor`	`batchPool`
`private ChoreService`	`choreService`
`private boolean`	`cleanupPool`
`private boolean`	`closed`
`protected String`	`clusterId`
`(package private) ClusterStatusListener`	`clusterStatusListener`
`private org.apache.hadoop.conf.Configuration`	`conf`
`private ConnectionConfiguration`	`connectionConfig`
`private RetryingCallerInterceptor`	`interceptor`
`private static org.slf4j.Logger`	`LOG`
`private Object`	`masterLock`
`(package private) ConnectionImplementation.MasterServiceState`	`masterServiceState`
`private MetaCache`	`metaCache`
`private ThreadPoolExecutor`	`metaLookupPool`
`private Object`	`metaRegionLock`
`private int`	`metaReplicaCallTimeoutScanInMicroSecond`
`private CatalogReplicaMode`	`metaReplicaMode`
`private CatalogReplicaLoadBalanceSelector`	`metaReplicaSelector`
`private MetricsConnection`	`metrics`
`private static NonceGenerator`	`nonceGenerator` Global nonceGenerator shared per client.
`private static Object`	`nonceGeneratorCreateLock` The nonce generator lock.
`private int`	`numTries`
`private ConnectionRegistry`	`registry` Cluster registry of basic info such as clusterid and meta region location.
`static String`	`RETRIES_BY_SERVER_KEY`
`private RpcRetryingCallerFactory`	`rpcCallerFactory`
`private RpcClient`	`rpcClient`
`private RpcControllerFactory`	`rpcControllerFactory`
`(package private) int`	`rpcTimeout`
`private ServerStatisticTracker`	`stats`
`private ConcurrentMap<String,Object>`	`stubs`
`protected User`	`user`
`private ReentrantLock`	`userRegionLock` lock guards against multiple threads trying to query the meta region at the same time

Fields inherited from interface org.apache.hadoop.hbase.client.ClusterConnection
HBASE_CLIENT_CONNECTION_IMPL

Constructor Summary

Constructors
Constructor and Description
`ConnectionImplementation(org.apache.hadoop.conf.Configuration conf, ExecutorService pool, User user)` constructor
`ConnectionImplementation(org.apache.hadoop.conf.Configuration conf, ExecutorService pool, User user, ConnectionRegistry registry)` Constructor, for creating cluster connection with provided ConnectionRegistry.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`abort(String msg, Throwable t)` Abort the server or client.
`void`	`cacheLocation(TableName tableName, RegionLocations location)` Put a newly discovered HRegionLocation into the cache.
`private void`	`cacheLocation(TableName tableName, ServerName source, HRegionLocation location)` Put a newly discovered HRegionLocation into the cache.
`private void`	`checkClosed()`
`void`	`clearCaches(ServerName serverName)` Clear any caches that pertain to server name `sn`.
`void`	`clearRegionCache(TableName tableName)` Allows flushing the region cache of all locations that pertain to `tableName`
`void`	`clearRegionCache(TableName tableName, byte[] row)`
`void`	`clearRegionLocationCache()` Clear all the entries in the region location cache, for all the tables.
`void`	`close()`
`private void`	`closeMaster()` Immediate close of the shared master.
`private void`	`closeMasterService(ConnectionImplementation.MasterServiceState mss)`
`void`	`deleteCachedRegionLocation(HRegionLocation location)` Deletes cached locations for the specific region.
`protected void`	`finalize()` Close the connection for good.
`private static <T> T`	`get(CompletableFuture<T> future)`
`Admin`	`getAdmin()` Retrieve an Admin implementation to administer an HBase cluster.
`org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	`getAdmin(ServerName serverName)` Establishes a connection to the region server at the specified address.
`org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	`getAdminForMaster()` Get the admin service for master.
`AsyncProcess`	`getAsyncProcess()` Returns Default AsyncProcess associated with this connection.
`ClientBackoffPolicy`	`getBackoffPolicy()` Returns the configured client backoff policy
`private ThreadPoolExecutor`	`getBatchPool()`
`BufferedMutator`	`getBufferedMutator(BufferedMutatorParams params)` Retrieve a `BufferedMutator` for performing client-side buffering of writes.
`BufferedMutator`	`getBufferedMutator(TableName tableName)` Retrieve a `BufferedMutator` for performing client-side buffering of writes.
`(package private) RegionLocations`	`getCachedLocation(TableName tableName, byte[] row)` Search the cache for a location that fits our table and row key.
`(package private) ChoreService`	`getChoreService()` If choreService has not been created yet, create the ChoreService.
`org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.BlockingInterface`	`getClient(ServerName serverName)` Establishes a connection to the region server at the specified address, and returns a region client protocol.
`String`	`getClusterId()` Returns the cluster ID unique to this HBase cluster.
`org.apache.hadoop.conf.Configuration`	`getConfiguration()` Returns Configuration instance being used by this Connection instance.
`ConnectionConfiguration`	`getConnectionConfiguration()` Returns a ConnectionConfiguration object holding parsed configuration values
`MetricsConnection`	`getConnectionMetrics()` Returns the MetricsConnection instance associated with this connection.
`ConnectionRegistry`	`getConnectionRegistry()` Get the `ConnectionRegistry` used to orient this cluster.
`protected ExecutorService`	`getCurrentBatchPool()`
`protected ExecutorService`	`getCurrentMetaLookupPool()`
`Hbck`	`getHbck()` Retrieve an Hbck implementation to fix an HBase cluster.
`Hbck`	`getHbck(ServerName masterServer)` Retrieve an Hbck implementation to fix an HBase cluster.
`private MasterKeepAliveConnection`	`getKeepAliveMasterService()`
`MasterKeepAliveConnection`	`getMaster()` Returns a `MasterKeepAliveConnection` to the active master
`private ThreadPoolExecutor`	`getMetaLookupPool()`
`RpcRetryingCallerFactory`	`getNewRpcRetryingCallerFactory(org.apache.hadoop.conf.Configuration conf)` Returns a new RpcRetryingCallerFactory from the given `Configuration`.
`NonceGenerator`	`getNonceGenerator()` Returns Nonce generator for this ClusterConnection; may be null if disabled in configuration.
`(package private) int`	`getNumberOfCachedRegionLocations(TableName tableName)`
`HRegionLocation`	`getRegionLocation(TableName tableName, byte[] row, boolean reload)` Find region location hosting passed row
`RegionLocator`	`getRegionLocator(TableName tableName)` Retrieve a RegionLocator implementation to inspect region information on a table.
`(package private) RpcClient`	`getRpcClient()` For tests only.
`RpcControllerFactory`	`getRpcControllerFactory()` Returns Connection's RpcControllerFactory instance
`RpcRetryingCallerFactory`	`getRpcRetryingCallerFactory()` Returns Connection's RpcRetryingCallerFactory instance
`ServerStatisticTracker`	`getStatisticsTracker()` Returns the current statistics tracker associated with this connection
`Table`	`getTable(TableName tableName)` Retrieve a Table implementation for accessing a table.
`TableBuilder`	`getTableBuilder(TableName tableName, ExecutorService pool)` Returns an `TableBuilder` for creating `Table`.
`TableState`	`getTableState(TableName tableName)` Retrieve TableState, represent current table state.
`private ThreadPoolExecutor`	`getThreadPool(int maxThreads, int coreThreads, String nameHint, BlockingQueue<Runnable> passedWorkQueue)`
`User`	`getUser()` Get the `User` associated with this connection.
`boolean`	`hasCellBlockSupport()` Returns true when this connection uses a `Codec` and so supports cell blocks.
`(package private) static NonceGenerator`	`injectNonceGeneratorForTesting(ClusterConnection conn, NonceGenerator cnm)`
`boolean`	`isAborted()` Check if the server or client was aborted.
`boolean`	`isClosed()` Returns whether the connection is closed or not.
`private boolean`	`isDeadServer(ServerName sn)`
`private boolean`	`isKeepAliveMasterConnectedAndRunning(ConnectionImplementation.MasterServiceState mss)`
`boolean`	`isMasterRunning()` Deprecated. this has been deprecated without a replacement
`boolean`	`isTableAvailable(TableName tableName, byte[][] splitKeys)` Use this api to check if the table has been created with the specified number of splitkeys which was used while creating the given table.
`boolean`	`isTableDisabled(TableName tableName)` Check if a table is disabled.
`boolean`	`isTableEnabled(TableName tableName)` A table that isTableEnabled == false and isTableDisabled == false is possible.
`private RegionLocations`	`locateMeta(TableName tableName, boolean useCache, int replicaId)`
`HRegionLocation`	`locateRegion(byte[] regionName)` Gets the location of the region of regionName.
`HRegionLocation`	`locateRegion(TableName tableName, byte[] row)` Find the location of the region of tableName that row lives in.
`RegionLocations`	`locateRegion(TableName tableName, byte[] row, boolean useCache, boolean retry)` Gets the locations of the region in the specified table, tableName, for a given row.
`RegionLocations`	`locateRegion(TableName tableName, byte[] row, boolean useCache, boolean retry, int replicaId)` Gets the locations of the region in the specified table, tableName, for a given row.
`private RegionLocations`	`locateRegionInMeta(TableName tableName, byte[] row, boolean useCache, boolean retry, int replicaId)` Search the hbase:meta table for the HRegionLocation info that contains the table and row we're seeking.
`List<HRegionLocation>`	`locateRegions(TableName tableName)` Gets the locations of all regions in the specified table, tableName.
`List<HRegionLocation>`	`locateRegions(TableName tableName, boolean useCache, boolean offlined)` Gets the locations of all regions in the specified table, tableName.
`private static void`	`release(ConnectionImplementation.MasterServiceState mss)`
`(package private) void`	`releaseMaster(ConnectionImplementation.MasterServiceState mss)`
`HRegionLocation`	`relocateRegion(TableName tableName, byte[] row)` Find the location of the region of tableName that row lives in, ignoring any value that might be in the cache.
`RegionLocations`	`relocateRegion(TableName tableName, byte[] row, int replicaId)` Find the location of the region of tableName that row lives in, ignoring any value that might be in the cache.
`private void`	`resetMasterServiceState(ConnectionImplementation.MasterServiceState mss)`
`protected void`	`retrieveClusterId()`
`private void`	`shutdownBatchPool(ExecutorService pool)`
`private void`	`shutdownPools()`
`private void`	`spawnRenewalChore(org.apache.hadoop.security.UserGroupInformation user)`
`(package private) void`	`takeUserRegionLock()`
`String`	`toString()` An identifier that will remain the same for a given connection.
`(package private) void`	`updateCachedLocation(RegionInfo hri, ServerName source, ServerName serverName, long seqNum)`
`void`	`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.

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.hadoop.hbase.client.ClusterConnection
clearRegionCache

Methods inherited from interface org.apache.hadoop.hbase.client.Connection
getTable

Methods inherited from interface org.apache.hadoop.hbase.Abortable
abort

- Field Detail
  - RETRIES_BY_SERVER_KEY
```
public static final String RETRIES_BY_SERVER_KEY
```
    See Also:
    
    Constant Field Values
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - metaReplicaMode
```
private CatalogReplicaMode metaReplicaMode
```
  - metaReplicaSelector
```
private CatalogReplicaLoadBalanceSelector metaReplicaSelector
```
  - metaReplicaCallTimeoutScanInMicroSecond
```
private final int metaReplicaCallTimeoutScanInMicroSecond
```
  - numTries
```
private final int numTries
```
  - rpcTimeout
```
final int rpcTimeout
```
  - nonceGenerator
```
private static volatile NonceGenerator nonceGenerator
```
    Global nonceGenerator shared per client. Currently there's no reason to limit its scope. Once it's set under nonceGeneratorCreateLock, it is never unset or changed.
  - nonceGeneratorCreateLock
```
private static final Object nonceGeneratorCreateLock
```
    The nonce generator lock. Only taken when creating Connection, which gets a private copy.
  - asyncProcess
```
private final AsyncProcess asyncProcess
```
  - stats
```
private final ServerStatisticTracker stats
```
  - closed
```
private volatile boolean closed
```
  - aborted
```
private volatile boolean aborted
```
  - clusterStatusListener
```
ClusterStatusListener clusterStatusListener
```
  - metaRegionLock
```
private final Object metaRegionLock
```
  - masterLock
```
private final Object masterLock
```
  - batchPool
```
private volatile ThreadPoolExecutor batchPool
```
  - metaLookupPool
```
private volatile ThreadPoolExecutor metaLookupPool
```
  - cleanupPool
```
private volatile boolean cleanupPool
```
  - conf
```
private final org.apache.hadoop.conf.Configuration conf
```
  - connectionConfig
```
private final ConnectionConfiguration connectionConfig
```
  - rpcClient
```
private final RpcClient rpcClient
```
  - metaCache
```
private final MetaCache metaCache
```
  - metrics
```
private final MetricsConnection metrics
```
  - user
```
protected User user
```
  - rpcCallerFactory
```
private final RpcRetryingCallerFactory rpcCallerFactory
```
  - rpcControllerFactory
```
private final RpcControllerFactory rpcControllerFactory
```
  - interceptor
```
private final RetryingCallerInterceptor interceptor
```
  - registry
```
private final ConnectionRegistry registry
```
    Cluster registry of basic info such as clusterid and meta region location.
  - backoffPolicy
```
private final ClientBackoffPolicy backoffPolicy
```
  - alternateBufferedMutatorClassName
```
private final String alternateBufferedMutatorClassName
```
    Allow setting an alternate BufferedMutator implementation via config. If null, use default.
  - userRegionLock
```
private final ReentrantLock userRegionLock
```
    lock guards against multiple threads trying to query the meta region at the same time
  - choreService
```
private ChoreService choreService
```
  - clusterId
```
protected String clusterId
```
  - stubs
```
private final ConcurrentMap<String,Object> stubs
```
  - masterServiceState
```
final ConnectionImplementation.MasterServiceState masterServiceState
```
- Constructor Detail
  - ConnectionImplementation
```
ConnectionImplementation(org.apache.hadoop.conf.Configuration conf,
                         ExecutorService pool,
                         User user)
                  throws IOException
```
    constructor
    
    Parameters:
    
    conf - Configuration object
    
    Throws:
    
    IOException
  - ConnectionImplementation
```
ConnectionImplementation(org.apache.hadoop.conf.Configuration conf,
                         ExecutorService pool,
                         User user,
                         ConnectionRegistry registry)
                  throws IOException
```
    Constructor, for creating cluster connection with provided ConnectionRegistry.
    
    Throws:
    
    IOException
- Method Detail
  - spawnRenewalChore
```
private void spawnRenewalChore(org.apache.hadoop.security.UserGroupInformation user)
```
  - injectNonceGeneratorForTesting
```
static NonceGenerator injectNonceGeneratorForTesting(ClusterConnection conn,
                                                     NonceGenerator cnm)
```
    Parameters:
    
    conn - The connection for which to replace the generator.
    
    cnm - Replaces the nonce generator used, for testing.
    
    Returns:
    
    old nonce generator.
  - getTable
```
public Table getTable(TableName tableName)
               throws IOException
```
    Description copied from interface: Connection
    
    Retrieve a Table implementation for accessing a table. The returned Table is not thread safe, a new instance should be created for each using thread. This is a lightweight operation, pooling or caching of the returned Table is neither required nor desired.
    The caller is responsible for calling Table.close() on the returned table instance.
    Since 0.98.1 this method no longer checks table existence. An exception will be thrown if the table does not exist only when the first operation is attempted.
    
    Specified by:
    
    getTable in interface Connection
    
    Parameters:
    
    tableName - the name of the table
    
    Returns:
    
    a Table to use for interactions with this table
    
    Throws:
    
    IOException
  - getTableBuilder
```
public TableBuilder getTableBuilder(TableName tableName,
                                    ExecutorService pool)
```
    Description copied from interface: Connection
    
    Returns an TableBuilder for creating Table.
    
    Specified by:
    
    getTableBuilder in interface Connection
    
    Parameters:
    
    tableName - the name of the table
    
    pool - the thread pool to use for requests like batch and scan
  - getBufferedMutator
```
public BufferedMutator getBufferedMutator(BufferedMutatorParams params)
```
    Description copied from interface: Connection
    
    Retrieve a BufferedMutator for performing client-side buffering of writes. The BufferedMutator returned by this method is thread-safe. This object can be used for long lived table operations. If user passes ThreadPool in BufferedMutatorParams then we will use that otherwise we will create for the user. For user specified ThreadPool, it is the user's responsibility to shutdown. For ThreadPool created by us, we will shutdown when user calls BufferedMutator.close(). The caller is responsible for calling BufferedMutator.close() on the returned BufferedMutator instance.
    
    Specified by:
    
    getBufferedMutator in interface Connection
    
    Parameters:
    
    params - details on how to instantiate the BufferedMutator.
    
    Returns:
    
    a BufferedMutator for the supplied tableName.
  - getBufferedMutator
```
public BufferedMutator getBufferedMutator(TableName tableName)
```
    Description copied from interface: Connection
    
    Retrieve a BufferedMutator for performing client-side buffering of writes. The BufferedMutator returned by this method is thread-safe. This accessor will create a new ThreadPoolExecutor and will be shutdown once we close the BufferedMutator. This object can be used for long lived operations.
    
    The caller is responsible for calling BufferedMutator.close() on the returned BufferedMutator instance.
    
    Specified by:
    
    getBufferedMutator in interface Connection
    
    Parameters:
    
    tableName - the name of the table
    
    Returns:
    
    a BufferedMutator for the supplied tableName.
  - getRegionLocator
```
public RegionLocator getRegionLocator(TableName tableName)
                               throws IOException
```
    Description copied from interface: Connection
    
    Retrieve a RegionLocator implementation to inspect region information on a table. The returned RegionLocator is not thread-safe, so a new instance should be created for each using thread. This is a lightweight operation. Pooling or caching of the returned RegionLocator is neither required nor desired.
    The caller is responsible for calling Closeable.close() on the returned RegionLocator instance. RegionLocator needs to be unmanaged
    
    Specified by:
    
    getRegionLocator in interface Connection
    
    Parameters:
    
    tableName - Name of the table who's region is to be examined
    
    Returns:
    
    A RegionLocator instance
    
    Throws:
    
    IOException
  - getAdmin
```
public Admin getAdmin()
               throws IOException
```
    Description copied from interface: Connection
    
    Retrieve an Admin implementation to administer an HBase cluster. The returned Admin is not guaranteed to be thread-safe. A new instance should be created for each using thread. This is a lightweight operation. Pooling or caching of the returned Admin is not recommended.
    The caller is responsible for calling Admin.close() on the returned Admin instance.
    
    Specified by:
    
    getAdmin in interface Connection
    
    Returns:
    
    an Admin instance for cluster administration
    
    Throws:
    
    IOException
  - getHbck
```
public Hbck getHbck()
             throws IOException
```
    Description copied from interface: Connection
    
    Retrieve an Hbck implementation to fix an HBase cluster. The returned Hbck is not guaranteed to be thread-safe. A new instance should be created by each thread. This is a lightweight operation. Pooling or caching of the returned Hbck instance is not recommended.
    The caller is responsible for calling Closeable.close() on the returned Hbck instance.
    This will be used mostly by hbck tool.
    
    Specified by:
    
    getHbck in interface Connection
    
    Returns:
    
    an Hbck instance for active master. Active master is fetched from the zookeeper.
    
    Throws:
    
    IOException
  - getHbck
```
public Hbck getHbck(ServerName masterServer)
             throws IOException
```
    Description copied from interface: Connection
    
    Retrieve an Hbck implementation to fix an HBase cluster. The returned Hbck is not guaranteed to be thread-safe. A new instance should be created by each thread. This is a lightweight operation. Pooling or caching of the returned Hbck instance is not recommended.
    The caller is responsible for calling Closeable.close() on the returned Hbck instance.
    This will be used mostly by hbck tool. This may only be used to by pass getting registered master from ZK. In situations where ZK is not available or active master is not registered with ZK and user can get master address by other means, master can be explicitly specified.
    
    Specified by:
    
    getHbck in interface Connection
    
    Parameters:
    
    masterServer - explicit ServerName for master server
    
    Returns:
    
    an Hbck instance for a specified master server
    
    Throws:
    
    IOException
  - getConnectionMetrics
```
public MetricsConnection getConnectionMetrics()
```
    Description copied from interface: ClusterConnection
    
    Returns the MetricsConnection instance associated with this connection.
    
    Specified by:
    
    getConnectionMetrics in interface ClusterConnection
  - getUser
```
public User getUser()
```
    Description copied from interface: ClusterConnection
    
    Get the User associated with this connection. May be null.
    
    Specified by:
    
    getUser in interface ClusterConnection
  - getConnectionRegistry
```
public ConnectionRegistry getConnectionRegistry()
```
    Description copied from interface: ClusterConnection
    
    Get the ConnectionRegistry used to orient this cluster.
    
    Specified by:
    
    getConnectionRegistry in interface ClusterConnection
  - getBatchPool
```
private ThreadPoolExecutor getBatchPool()
```
  - getThreadPool
```
private ThreadPoolExecutor getThreadPool(int maxThreads,
                                         int coreThreads,
                                         String nameHint,
                                         BlockingQueue<Runnable> passedWorkQueue)
```
  - getMetaLookupPool
```
private ThreadPoolExecutor getMetaLookupPool()
```
  - getCurrentMetaLookupPool
```
protected ExecutorService getCurrentMetaLookupPool()
```
  - getCurrentBatchPool
```
protected ExecutorService getCurrentBatchPool()
```
  - shutdownPools
```
private void shutdownPools()
```
  - shutdownBatchPool
```
private void shutdownBatchPool(ExecutorService pool)
```
  - getRpcClient
```
RpcClient getRpcClient()
```
    For tests only.
  - toString
```
public String toString()
```
    An identifier that will remain the same for a given connection.
    
    Overrides:
    
    toString in class Object
  - retrieveClusterId
```
protected void retrieveClusterId()
```
  - getChoreService
```
ChoreService getChoreService()
```
    If choreService has not been created yet, create the ChoreService. n
  - getConfiguration
```
public org.apache.hadoop.conf.Configuration getConfiguration()
```
    Description copied from interface: Connection
    
    Returns Configuration instance being used by this Connection instance.
    
    Specified by:
    
    getConfiguration in interface Connection
  - checkClosed
```
private void checkClosed()
                  throws ConnectionImplementation.LocalConnectionClosedException
```
    Throws:
    
    ConnectionImplementation.LocalConnectionClosedException
  - isMasterRunning
```
@Deprecated
public boolean isMasterRunning()
                                    throws MasterNotRunningException,
                                           ZooKeeperConnectionException
```
    Deprecated. this has been deprecated without a replacement
    
    Specified by:
    
    isMasterRunning in interface ClusterConnection
    
    Returns:
    
    true if the master is running, throws an exception otherwise
    
    Throws:
    
    MasterNotRunningException - - if the master is not running
    
    ZooKeeperConnectionException
  - getRegionLocation
```
public HRegionLocation getRegionLocation(TableName tableName,
                                         byte[] row,
                                         boolean reload)
                                  throws IOException
```
    Description copied from interface: ClusterConnection
    
    Find region location hosting passed row
    
    Specified by:
    
    getRegionLocation in interface ClusterConnection
    
    Parameters:
    
    tableName - table name
    
    row - Row to find.
    
    reload - If true do not use cache, otherwise bypass.
    
    Returns:
    
    Location of row.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableEnabled
```
public boolean isTableEnabled(TableName tableName)
                       throws IOException
```
    Description copied from interface: ClusterConnection
    
    A table that isTableEnabled == false and isTableDisabled == false is possible. This happens when a table has a lot of regions that must be processed.
    
    Specified by:
    
    isTableEnabled in interface ClusterConnection
    
    Parameters:
    
    tableName - table name
    
    Returns:
    
    true if the table is enabled, false otherwise
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableDisabled
```
public boolean isTableDisabled(TableName tableName)
                        throws IOException
```
    Description copied from interface: ClusterConnection
    
    Check if a table is disabled.
    
    Specified by:
    
    isTableDisabled in interface ClusterConnection
    
    Parameters:
    
    tableName - table name
    
    Returns:
    
    true if the table is disabled, false otherwise
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableAvailable
```
public boolean isTableAvailable(TableName tableName,
                                @Nullable
                                byte[][] splitKeys)
                         throws IOException
```
    Description copied from interface: ClusterConnection
    
    Use this api to check if the table has been created with the specified number of splitkeys which was used while creating the given table. Note : If this api is used after a table's region gets splitted, the api may return false. n * tableName n * splitKeys used while creating table n * if a remote or network exception occurs
    
    Specified by:
    
    isTableAvailable in interface ClusterConnection
    
    Throws:
    
    IOException
  - locateRegion
```
public HRegionLocation locateRegion(byte[] regionName)
                             throws IOException
```
    Description copied from interface: ClusterConnection
    
    Gets the location of the region of regionName.
    
    Specified by:
    
    locateRegion in interface ClusterConnection
    
    Parameters:
    
    regionName - name of the region to locate
    
    Returns:
    
    HRegionLocation that describes where to find the region in question
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isDeadServer
```
private boolean isDeadServer(ServerName sn)
```
  - locateRegions
```
public List<HRegionLocation> locateRegions(TableName tableName)
                                    throws IOException
```
    Description copied from interface: ClusterConnection
    
    Gets the locations of all regions in the specified table, tableName.
    
    Specified by:
    
    locateRegions in interface ClusterConnection
    
    Parameters:
    
    tableName - table to get regions of
    
    Returns:
    
    list of region locations for all regions of table
    
    Throws:
    
    IOException - if IO failure occurs
  - locateRegions
```
public List<HRegionLocation> locateRegions(TableName tableName,
                                           boolean useCache,
                                           boolean offlined)
                                    throws IOException
```
    Description copied from interface: ClusterConnection
    
    Gets the locations of all regions in the specified table, tableName.
    
    Specified by:
    
    locateRegions in interface ClusterConnection
    
    Parameters:
    
    tableName - table to get regions of
    
    useCache - Should we use the cache to retrieve the region information.
    
    offlined - True if we are to include offlined regions, false and we'll leave out offlined regions from returned list.
    
    Returns:
    
    list of region locations for all regions of table
    
    Throws:
    
    IOException - if IO failure occurs
  - locateRegion
```
public HRegionLocation locateRegion(TableName tableName,
                                    byte[] row)
                             throws IOException
```
    Description copied from interface: ClusterConnection
    
    Find the location of the region of tableName that row lives in.
    
    Specified by:
    
    locateRegion in interface ClusterConnection
    
    Parameters:
    
    tableName - name of the table row is in
    
    row - row key you're trying to find the region of
    
    Returns:
    
    HRegionLocation that describes where to find the region in question
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - relocateRegion
```
public HRegionLocation relocateRegion(TableName tableName,
                                      byte[] row)
                               throws IOException
```
    Description copied from interface: ClusterConnection
    
    Find the location of the region of tableName that row lives in, ignoring any value that might be in the cache.
    
    Specified by:
    
    relocateRegion in interface ClusterConnection
    
    Parameters:
    
    tableName - name of the table row is in
    
    row - row key you're trying to find the region of
    
    Returns:
    
    HRegionLocation that describes where to find the region in question
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - relocateRegion
```
public RegionLocations relocateRegion(TableName tableName,
                                      byte[] row,
                                      int replicaId)
                               throws IOException
```
    Description copied from interface: ClusterConnection
    
    Find the location of the region of tableName that row lives in, ignoring any value that might be in the cache.
    
    Specified by:
    
    relocateRegion in interface ClusterConnection
    
    Parameters:
    
    tableName - name of the table row is in
    
    row - row key you're trying to find the region of
    
    replicaId - the replicaId of the region
    
    Returns:
    
    RegionLocations that describe where to find the region in question
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - locateRegion
```
public RegionLocations locateRegion(TableName tableName,
                                    byte[] row,
                                    boolean useCache,
                                    boolean retry)
                             throws IOException
```
    Description copied from interface: ClusterConnection
    
    Gets the locations of the region in the specified table, tableName, for a given row.
    
    Specified by:
    
    locateRegion in interface ClusterConnection
    
    Parameters:
    
    tableName - table to get regions of
    
    row - the row
    
    useCache - Should we use the cache to retrieve the region information.
    
    retry - do we retry
    
    Returns:
    
    region locations for this row.
    
    Throws:
    
    IOException - if IO failure occurs
  - locateRegion
```
public RegionLocations locateRegion(TableName tableName,
                                    byte[] row,
                                    boolean useCache,
                                    boolean retry,
                                    int replicaId)
                             throws IOException
```
    Description copied from interface: ClusterConnection
    
    Gets the locations of the region in the specified table, tableName, for a given row.
    
    Specified by:
    
    locateRegion in interface ClusterConnection
    
    Parameters:
    
    tableName - table to get regions of
    
    row - the row
    
    useCache - Should we use the cache to retrieve the region information.
    
    retry - do we retry
    
    replicaId - the replicaId for the region
    
    Returns:
    
    region locations for this row.
    
    Throws:
    
    IOException - if IO failure occurs
  - locateMeta
```
private RegionLocations locateMeta(TableName tableName,
                                   boolean useCache,
                                   int replicaId)
                            throws IOException
```
    Throws:
    
    IOException
  - locateRegionInMeta
```
private RegionLocations locateRegionInMeta(TableName tableName,
                                           byte[] row,
                                           boolean useCache,
                                           boolean retry,
                                           int replicaId)
                                    throws IOException
```
    Search the hbase:meta table for the HRegionLocation info that contains the table and row we're seeking.
    
    Throws:
    
    IOException
  - takeUserRegionLock
```
void takeUserRegionLock()
                 throws IOException
```
    Throws:
    
    IOException
  - cacheLocation
```
public void cacheLocation(TableName tableName,
                          RegionLocations location)
```
    Put a newly discovered HRegionLocation into the cache.
    
    Specified by:
    
    cacheLocation in interface ClusterConnection
    
    Parameters:
    
    tableName - The table name.
    
    location - the new location
  - getCachedLocation
```
RegionLocations getCachedLocation(TableName tableName,
                                  byte[] row)
```
    Search the cache for a location that fits our table and row key. Return null if no suitable region is located.
    
    Returns:
    
    Null or region location found in cache.
  - clearRegionCache
```
public void clearRegionCache(TableName tableName,
                             byte[] row)
```
  - clearCaches
```
public void clearCaches(ServerName serverName)
```
    Description copied from interface: ClusterConnection
    
    Clear any caches that pertain to server name sn.
    
    Specified by:
    
    clearCaches in interface ClusterConnection
    
    Parameters:
    
    serverName - A server name
  - clearRegionLocationCache
```
public void clearRegionLocationCache()
```
    Description copied from interface: Connection
    
    Clear all the entries in the region location cache, for all the tables.
    If you only want to clear the cache for a specific table, use RegionLocator.clearRegionLocationCache().
    This may cause performance issue so use it with caution.
    
    Specified by:
    
    clearRegionLocationCache in interface Connection
  - clearRegionCache
```
public void clearRegionCache(TableName tableName)
```
    Description copied from interface: ClusterConnection
    
    Allows flushing the region cache of all locations that pertain to tableName
    
    Specified by:
    
    clearRegionCache in interface ClusterConnection
    
    Parameters:
    
    tableName - Name of the table whose regions we are to remove from cache.
  - cacheLocation
```
private void cacheLocation(TableName tableName,
                           ServerName source,
                           HRegionLocation location)
```
    Put a newly discovered HRegionLocation into the cache.
    
    Parameters:
    
    tableName - The table name.
    
    source - the source of the new location, if it's not coming from meta
    
    location - the new location
  - getAdminForMaster
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface getAdminForMaster()
                                                                                                               throws IOException
```
    Description copied from interface: ClusterConnection
    
    Get the admin service for master.
    
    Specified by:
    
    getAdminForMaster in interface ClusterConnection
    
    Throws:
    
    IOException
  - getAdmin
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.BlockingInterface getAdmin(ServerName serverName)
                                                                                                      throws IOException
```
    Description copied from interface: ClusterConnection
    
    Establishes a connection to the region server at the specified address.
    
    Specified by:
    
    getAdmin in interface ClusterConnection
    
    Parameters:
    
    serverName - the region server to connect to
    
    Returns:
    
    proxy for HRegionServer
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getClient
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.BlockingInterface getClient(ServerName serverName)
                                                                                                         throws IOException
```
    Description copied from interface: ClusterConnection
    
    Establishes a connection to the region server at the specified address, and returns a region client protocol.
    
    Specified by:
    
    getClient in interface ClusterConnection
    
    Parameters:
    
    serverName - the region server to connect to
    
    Returns:
    
    ClientProtocol proxy for RegionServer
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getMaster
```
public MasterKeepAliveConnection getMaster()
                                    throws IOException
```
    Description copied from interface: ClusterConnection
    
    Returns a MasterKeepAliveConnection to the active master
    
    Specified by:
    
    getMaster in interface ClusterConnection
    
    Throws:
    
    IOException
  - resetMasterServiceState
```
private void resetMasterServiceState(ConnectionImplementation.MasterServiceState mss)
```
  - getKeepAliveMasterService
```
private MasterKeepAliveConnection getKeepAliveMasterService()
                                                     throws IOException
```
    Throws:
    
    IOException
  - release
```
private static void release(ConnectionImplementation.MasterServiceState mss)
```
  - isKeepAliveMasterConnectedAndRunning
```
private boolean isKeepAliveMasterConnectedAndRunning(ConnectionImplementation.MasterServiceState mss)
```
  - releaseMaster
```
void releaseMaster(ConnectionImplementation.MasterServiceState mss)
```
  - closeMasterService
```
private void closeMasterService(ConnectionImplementation.MasterServiceState mss)
```
  - closeMaster
```
private void closeMaster()
```
    Immediate close of the shared master. Can be by the delayed close or when closing the connection itself.
  - updateCachedLocation
```
void updateCachedLocation(RegionInfo hri,
                          ServerName source,
                          ServerName serverName,
                          long seqNum)
```
  - deleteCachedRegionLocation
```
public void deleteCachedRegionLocation(HRegionLocation location)
```
    Description copied from interface: ClusterConnection
    
    Deletes cached locations for the specific region.
    
    Specified by:
    
    deleteCachedRegionLocation in interface ClusterConnection
    
    Parameters:
    
    location - The location object for the region, to be purged from cache.
  - updateCachedLocations
```
public void 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. Does nothing if we can be sure from the exception that the location is still accurate, or if the cache has already been updated.
    
    Specified by:
    
    updateCachedLocations in interface ClusterConnection
    
    Parameters:
    
    exception - an object (to simplify user code) on which we will try to find a nested or wrapped or both RegionMovedException
    
    source - server that is the source of the location update.
    
    tableName - the table name
    
    regionName - the region name
    
    rowkey - the row
  - getAsyncProcess
```
public AsyncProcess getAsyncProcess()
```
    Description copied from interface: ClusterConnection
    
    Returns Default AsyncProcess associated with this connection.
    
    Specified by:
    
    getAsyncProcess in interface ClusterConnection
  - getStatisticsTracker
```
public ServerStatisticTracker getStatisticsTracker()
```
    Description copied from interface: ClusterConnection
    
    Returns the current statistics tracker associated with this connection
    
    Specified by:
    
    getStatisticsTracker in interface ClusterConnection
  - getBackoffPolicy
```
public ClientBackoffPolicy getBackoffPolicy()
```
    Description copied from interface: ClusterConnection
    
    Returns the configured client backoff policy
    
    Specified by:
    
    getBackoffPolicy in interface ClusterConnection
  - getNumberOfCachedRegionLocations
```
int getNumberOfCachedRegionLocations(TableName tableName)
```
  - abort
```
public void abort(String msg,
                  Throwable t)
```
    Description copied from interface: Abortable
    
    Abort the server or client.
    
    Specified by:
    
    abort in interface Abortable
    
    Parameters:
    
    msg - Why we're aborting.
    
    t - Throwable that caused abort. Can be null.
  - isClosed
```
public boolean isClosed()
```
    Description copied from interface: Connection
    
    Returns whether the connection is closed or not.
    
    Specified by:
    
    isClosed in interface Connection
    
    Returns:
    
    true if this connection is closed
  - isAborted
```
public boolean isAborted()
```
    Description copied from interface: Abortable
    
    Check if the server or client was aborted.
    
    Specified by:
    
    isAborted in interface Abortable
    
    Returns:
    
    true if the server or client was aborted, false otherwise
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Connection
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Close the connection for good. On the off chance that someone is unable to close the connection, perhaps because it bailed out prematurely, the method below will ensure that this instance is cleaned up. Caveat: The JVM may take an unknown amount of time to call finalize on an unreachable object, so our hope is that every consumer cleans up after itself, like any good citizen.
    
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - getNonceGenerator
```
public NonceGenerator getNonceGenerator()
```
    Description copied from interface: ClusterConnection
    
    Returns Nonce generator for this ClusterConnection; may be null if disabled in configuration.
    
    Specified by:
    
    getNonceGenerator in interface ClusterConnection
  - getTableState
```
public TableState getTableState(TableName tableName)
                         throws IOException
```
    Description copied from interface: ClusterConnection
    
    Retrieve TableState, represent current table state.
    
    Specified by:
    
    getTableState in interface ClusterConnection
    
    Parameters:
    
    tableName - table state for
    
    Returns:
    
    state of the table
    
    Throws:
    
    IOException
  - getNewRpcRetryingCallerFactory
```
public RpcRetryingCallerFactory getNewRpcRetryingCallerFactory(org.apache.hadoop.conf.Configuration conf)
```
    Description copied from interface: ClusterConnection
    
    Returns a new RpcRetryingCallerFactory from the given Configuration. This RpcRetryingCallerFactory lets the users create RpcRetryingCallers which can be intercepted with the configured RetryingCallerInterceptor
    
    Specified by:
    
    getNewRpcRetryingCallerFactory in interface ClusterConnection
    
    Parameters:
    
    conf - configuration n
  - hasCellBlockSupport
```
public boolean hasCellBlockSupport()
```
    Description copied from interface: ClusterConnection
    
    Returns true when this connection uses a Codec and so supports cell blocks.
    
    Specified by:
    
    hasCellBlockSupport in interface ClusterConnection
  - getConnectionConfiguration
```
public ConnectionConfiguration getConnectionConfiguration()
```
    Description copied from interface: ClusterConnection
    
    Returns a ConnectionConfiguration object holding parsed configuration values
    
    Specified by:
    
    getConnectionConfiguration in interface ClusterConnection
  - getRpcRetryingCallerFactory
```
public RpcRetryingCallerFactory getRpcRetryingCallerFactory()
```
    Description copied from interface: ClusterConnection
    
    Returns Connection's RpcRetryingCallerFactory instance
    
    Specified by:
    
    getRpcRetryingCallerFactory in interface ClusterConnection
  - getRpcControllerFactory
```
public RpcControllerFactory getRpcControllerFactory()
```
    Description copied from interface: ClusterConnection
    
    Returns Connection's RpcControllerFactory instance
    
    Specified by:
    
    getRpcControllerFactory in interface ClusterConnection
  - get
```
private static <T> T get(CompletableFuture<T> future)
                  throws IOException
```
    Throws:
    
    IOException
  - getClusterId
```
public String getClusterId()
```
    Description copied from interface: Connection
    
    Returns the cluster ID unique to this HBase cluster.
    The default implementation is added to keep client compatibility.
    
    Specified by:
    
    getClusterId in interface Connection

Class ConnectionImplementation

Nested Class Summary

Field Summary

Fields inherited from interface org.apache.hadoop.hbase.client.ClusterConnection

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.hadoop.hbase.client.ClusterConnection

Methods inherited from interface org.apache.hadoop.hbase.client.Connection

Methods inherited from interface org.apache.hadoop.hbase.Abortable

Field Detail

RETRIES_BY_SERVER_KEY

LOG

metaReplicaMode

metaReplicaSelector

metaReplicaCallTimeoutScanInMicroSecond

numTries

rpcTimeout

nonceGenerator

nonceGeneratorCreateLock

asyncProcess

stats

closed

aborted

clusterStatusListener

metaRegionLock

masterLock

batchPool

metaLookupPool

cleanupPool

conf

connectionConfig

rpcClient

metaCache

metrics

user

rpcCallerFactory

rpcControllerFactory

interceptor

registry

backoffPolicy

alternateBufferedMutatorClassName

userRegionLock

choreService

clusterId

stubs

masterServiceState

Constructor Detail

ConnectionImplementation

ConnectionImplementation

Method Detail

spawnRenewalChore

injectNonceGeneratorForTesting

getTable

getTableBuilder

getBufferedMutator

getBufferedMutator

getRegionLocator

getAdmin

getHbck

getHbck

getConnectionMetrics

getUser

getConnectionRegistry

getBatchPool

getThreadPool

getMetaLookupPool

getCurrentMetaLookupPool

getCurrentBatchPool

shutdownPools

shutdownBatchPool

getRpcClient

toString

retrieveClusterId

getChoreService

getConfiguration

checkClosed

isMasterRunning

getRegionLocation

isTableEnabled