CoprocessorHConnection (Apache HBase 1.4.11 API)

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

All Implemented Interfaces:

Closeable, AutoCloseable, Abortable, ClusterConnection, Connection, HConnection
```
@InterfaceAudience.Private
@InterfaceStability.Evolving
public class CoprocessorHConnection
extends Object
```
Connection to an HTable from within a Coprocessor. We can do some nice tricks since we know we are on a regionserver, for instance skipping the full serialization/deserialization of objects when talking to the server.
You should not use this class from any client - its an internal class meant for use by the coprocessor framework.

Field Summary

Fields
Modifier and Type Field and Description

protected String clusterId

protected User user
- Fields inherited from interface org.apache.hadoop.hbase.client.HConnection
  HBASE_CLIENT_CONNECTION_IMPL

Fields
Modifier and Type	Field and Description
`protected String`	`clusterId`
`protected User`	`user`

Constructor Summary

Constructors
Constructor and Description
`CoprocessorHConnection(ClusterConnection delegate, HRegionServer server)` Deprecated. delegate is not used
`CoprocessorHConnection(org.apache.hadoop.conf.Configuration conf, HRegionServer server)` Constructor that accepts custom configuration
`CoprocessorHConnection(HRegionServer server)` Constructor that uses server configuration

Method Summary

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.
`void`	`clearCaches(ServerName serverName)` Clear any caches that pertain to server name `sn`.
`void`	`clearRegionCache()` Allows flushing the region cache.
`void`	`clearRegionCache(byte[] tableName)`
`void`	`clearRegionCache(TableName tableName)` Allows flushing the region cache of all locations that pertain to `tableName`
`void`	`clearRegionCache(TableName tableName, byte[] row)`
`void`	`close()`
`protected org.apache.hadoop.hbase.client.AsyncProcess`	`createAsyncProcess(org.apache.hadoop.conf.Configuration conf)`
`void`	`deleteCachedRegionLocation(HRegionLocation location)` Deletes cached locations for the specific region.
`protected void`	`finalize()` Close the connection for good, regardless of what the current value of `refCount` is.
`Admin`	`getAdmin()` Retrieve an Admin implementation to administer an HBase cluster.
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	`getAdmin(ServerName serverName)` Establishes a connection to the region server at the specified address.
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	`getAdmin(ServerName serverName, boolean master)` Establishes a connection to the region server at the specified address.
`org.apache.hadoop.hbase.client.AsyncProcess`	`getAsyncProcess()`
`ClientBackoffPolicy`	`getBackoffPolicy()`
`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.
`org.apache.hadoop.hbase.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.
`org.apache.hadoop.conf.Configuration`	`getConfiguration()`
`ConnectionConfiguration`	`getConnectionConfiguration()`
`static ClusterConnection`	`getConnectionForEnvironment(CoprocessorEnvironment env)` Create an unmanaged `HConnection` based on the environment in which we are running the coprocessor.
`MetricsConnection`	`getConnectionMetrics()`
`protected ExecutorService`	`getCurrentBatchPool()`
`protected ExecutorService`	`getCurrentMetaLookupPool()`
`int`	`getCurrentNrHRS()`
`HTableDescriptor`	`getHTableDescriptor(byte[] tableName)` Deprecated. Use `Admin.getTableDescriptor(TableName)` instead
`HTableDescriptor`	`getHTableDescriptor(TableName tableName)` Deprecated. Use `Admin.getTableDescriptor(TableName)` instead
`HTableDescriptor[]`	`getHTableDescriptors(List<String> names)` Deprecated. Use `Admin.getTableDescriptorsByTableName(List)` instead
`HTableDescriptor[]`	`getHTableDescriptorsByTableName(List<TableName> tableNames)` Deprecated. Use `Admin.getTableDescriptorsByTableName(List)` instead
`org.apache.hadoop.hbase.client.MasterKeepAliveConnection`	`getKeepAliveMasterService()` This function allows HBaseAdmin and potentially others to get a shared MasterService connection.
`org.apache.hadoop.hbase.protobuf.generated.MasterProtos.MasterService.BlockingInterface`	`getMaster()` Returns a `MasterKeepAliveConnection` to the active master
`RpcRetryingCallerFactory`	`getNewRpcRetryingCallerFactory(org.apache.hadoop.conf.Configuration conf)` Returns a new RpcRetryingCallerFactory from the given `Configuration`.
`NonceGenerator`	`getNonceGenerator()`
`boolean`	`getRegionCachePrefetch(byte[] tableName)` Deprecated.
`boolean`	`getRegionCachePrefetch(TableName tableName)` Deprecated.
`HRegionLocation`	`getRegionLocation(byte[] tableName, byte[] row, boolean reload)`
`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.
`RpcControllerFactory`	`getRpcControllerFactory()`
`RpcRetryingCallerFactory`	`getRpcRetryingCallerFactory()`
`ServerStatisticTracker`	`getStatisticsTracker()`
`HTableInterface`	`getTable(byte[] tableName)` Retrieve an HTableInterface implementation for access to a table.
`HTableInterface`	`getTable(byte[] tableName, ExecutorService pool)` Retrieve an HTableInterface implementation for access to a table.
`HTableInterface`	`getTable(String tableName)` Retrieve an HTableInterface implementation for access to a table.
`HTableInterface`	`getTable(String tableName, ExecutorService pool)` Retrieve an HTableInterface implementation for access to a table.
`HTableInterface`	`getTable(TableName tableName)` Retrieve an HTableInterface implementation for access to a table.
`HTableInterface`	`getTable(TableName tableName, ExecutorService pool)` Retrieve an HTableInterface implementation for access to a table.
`String[]`	`getTableNames()` Deprecated. Use `Admin.listTableNames()` instead
`boolean`	`hasCellBlockSupport()`
`boolean`	`isAborted()` Check if the server or client was aborted.
`boolean`	`isClosed()` Returns whether the connection is closed or not.
`boolean`	`isDeadServer(ServerName sn)`
`boolean`	`isManaged()`
`boolean`	`isMasterRunning()` Deprecated.
`boolean`	`isTableAvailable(byte[] tableName)`
`boolean`	`isTableAvailable(byte[] tableName, byte[][] splitKeys)`
`boolean`	`isTableAvailable(TableName tableName)`
`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(byte[] tableName)`
`boolean`	`isTableDisabled(TableName tableName)`
`boolean`	`isTableEnabled(byte[] tableName)`
`boolean`	`isTableEnabled(TableName tableName)` A table that isTableEnabled == false and isTableDisabled == false is possible.
`TableName[]`	`listTableNames()` Deprecated. Use `Admin.listTableNames()` instead
`HTableDescriptor[]`	`listTables()` Deprecated. Use `Admin.listTables()` instead
`HRegionLocation`	`locateRegion(byte[] regionName)` Gets the location of the region of regionName.
`HRegionLocation`	`locateRegion(byte[] tableName, byte[] row)`
`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)`
`RegionLocations`	`locateRegion(TableName tableName, byte[] row, boolean useCache, boolean retry, int replicaId)`
`List<HRegionLocation>`	`locateRegions(byte[] tableName)`
`List<HRegionLocation>`	`locateRegions(byte[] tableName, boolean useCache, boolean offlined)`
`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.
`void`	`processBatch(List<? extends Row> list, byte[] tableName, ExecutorService pool, Object[] results)` Deprecated.
`void`	`processBatch(List<? extends Row> list, TableName tableName, ExecutorService pool, Object[] results)` Deprecated.
`<R> void`	`processBatchCallback(List<? extends Row> list, byte[] tableName, ExecutorService pool, Object[] results, Batch.Callback<R> callback)` Deprecated.
`<R> void`	`processBatchCallback(List<? extends Row> list, TableName tableName, ExecutorService pool, Object[] results, Batch.Callback<R> callback)` Deprecated. since 0.96 - Use `HTable.processBatchCallback(java.util.List<? extends org.apache.hadoop.hbase.client.Row>, java.lang.Object[], org.apache.hadoop.hbase.client.coprocessor.Batch.Callback<R>)` instead
`HRegionLocation`	`relocateRegion(byte[] tableName, byte[] row)`
`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.
`void`	`setRegionCachePrefetch(byte[] tableName, boolean enable)` Deprecated.
`void`	`setRegionCachePrefetch(TableName tableName, boolean enable)` Deprecated.
`String`	`toString()` An identifier that will remain the same for a given connection.
`void`	`updateCachedLocations(byte[] tableName, byte[] rowkey, Object exception, HRegionLocation source)`
`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.
`void`	`updateCachedLocations(TableName tableName, byte[] rowkey, Object exception, HRegionLocation source)`

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

- Field Detail
  - user
```
protected User user
```
  - clusterId
```
protected String clusterId
```
- Constructor Detail
  - CoprocessorHConnection
```
@Deprecated
public CoprocessorHConnection(ClusterConnection delegate,
                                 HRegionServer server)
                       throws IOException
```
    Deprecated. delegate is not used
    
    Legacy constructor
    
    Parameters:
    delegate -
    server -
    
    Throws:
    
    IOException - if we cannot create the connection
  - CoprocessorHConnection
```
public CoprocessorHConnection(HRegionServer server)
                       throws IOException
```
    Constructor that uses server configuration
    
    Parameters:
    server -
    
    Throws:
    
    IOException - if we cannot create the connection
  - CoprocessorHConnection
```
public CoprocessorHConnection(org.apache.hadoop.conf.Configuration conf,
                      HRegionServer server)
                       throws IOException
```
    Constructor that accepts custom configuration
    
    Parameters:
    conf -
    server -
    
    Throws:
    
    IOException - if we cannot create the connection
- Method Detail
  - getConnectionForEnvironment
```
public static ClusterConnection getConnectionForEnvironment(CoprocessorEnvironment env)
                                                     throws IOException
```
    Create an unmanaged HConnection based on the environment in which we are running the coprocessor. The HConnection must be externally cleaned up (we bypass the usual HTable cleanup mechanisms since we own everything).
    
    Parameters:
    env - environment hosting the HConnection
    
    Returns:
    an unmanaged HConnection.
    
    Throws:
    
    IOException - if we cannot create the connection
  - getClient
```
public org.apache.hadoop.hbase.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
    
    Specified by:
    
    getClient in interface HConnection
    
    Returns:
    ClientProtocol proxy for RegionServer
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getNonceGenerator
```
public NonceGenerator getNonceGenerator()
```
    Specified by:
    
    getNonceGenerator in interface ClusterConnection
    
    Specified by:
    
    getNonceGenerator in interface HConnection
    
    Returns:
    Nonce generator for this HConnection; may be null if disabled in configuration.
  - getTable
```
public HTableInterface getTable(String tableName)
                         throws IOException
```
    Description copied from interface: HConnection
    
    Retrieve an HTableInterface implementation for access to a table. The returned HTableInterface 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 HTableInterface is neither required nor desired. Note that the HConnection needs to be unmanaged (created with HConnectionManager.createConnection(Configuration)).
    
    Specified by:
    
    getTable in interface HConnection
    
    Returns:
    an HTable to use for interactions with this table
    
    Throws:
    
    IOException
  - getTable
```
public HTableInterface getTable(byte[] tableName)
                         throws IOException
```
    Description copied from interface: HConnection
    
    Retrieve an HTableInterface implementation for access to a table. The returned HTableInterface 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 HTableInterface is neither required nor desired. Note that the HConnection needs to be unmanaged (created with HConnectionManager.createConnection(Configuration)).
    
    Specified by:
    
    getTable in interface HConnection
    
    Returns:
    an HTable to use for interactions with this table
    
    Throws:
    
    IOException
  - getTable
```
public HTableInterface getTable(TableName tableName)
                         throws IOException
```
    Description copied from interface: HConnection
    
    Retrieve an HTableInterface implementation for access to a table. The returned HTableInterface 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 HTableInterface is neither required nor desired. Note that the HConnection needs to be unmanaged (created with HConnectionManager.createConnection(Configuration)).
    
    Specified by:
    
    getTable in interface Connection
    
    Specified by:
    
    getTable in interface HConnection
    
    Parameters:
    tableName - the name of the table
    
    Returns:
    an HTable to use for interactions with this table
    
    Throws:
    
    IOException
  - getTable
```
public HTableInterface getTable(String tableName,
                       ExecutorService pool)
                         throws IOException
```
    Description copied from interface: HConnection
    
    Retrieve an HTableInterface implementation for access to a table. The returned HTableInterface 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 HTableInterface is neither required nor desired. Note that the HConnection needs to be unmanaged (created with HConnectionManager.createConnection(Configuration)).
    
    Specified by:
    
    getTable in interface HConnection
    
    pool - The thread pool to use for batch operations, null to use a default pool.
    
    Returns:
    an HTable to use for interactions with this table
    
    Throws:
    
    IOException
  - getTable
```
public HTableInterface getTable(byte[] tableName,
                       ExecutorService pool)
                         throws IOException
```
    Description copied from interface: HConnection
    
    Retrieve an HTableInterface implementation for access to a table. The returned HTableInterface 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 HTableInterface is neither required nor desired. Note that the HConnection needs to be unmanaged (created with HConnectionManager.createConnection(Configuration)).
    
    Specified by:
    
    getTable in interface HConnection
    
    pool - The thread pool to use for batch operations, null to use a default pool.
    
    Returns:
    an HTable to use for interactions with this table
    
    Throws:
    
    IOException
  - getTable
```
public HTableInterface getTable(TableName tableName,
                       ExecutorService pool)
                         throws IOException
```
    Description copied from interface: HConnection
    
    Retrieve an HTableInterface implementation for access to a table. The returned HTableInterface 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 HTableInterface is neither required nor desired. Note that the HConnection needs to be unmanaged (created with HConnectionManager.createConnection(Configuration)).
    
    Specified by:
    
    getTable in interface Connection
    
    Specified by:
    
    getTable in interface HConnection
    
    Parameters:
    tableName - the name of the table
    pool - The thread pool to use for batch operations, null to use a default pool.
    
    Returns:
    an HTable to use for interactions with this table
    
    Throws:
    
    IOException
  - 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. 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 BufferedMutator will use the Connection's ExecutorService. This object can be used for long lived operations.
    
    The caller is responsible for calling BufferedMutator.close() on the returned BufferedMutator instance.
    
    This accessor will use the connection's ExecutorService and will throw an exception in the main thread when an asynchronous exception occurs.
    
    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: HConnection
    
    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. RegionLocator needs to be unmanaged (created with HConnectionManager.createConnection(Configuration)).
    
    Specified by:
    
    getRegionLocator in interface Connection
    
    Specified by:
    
    getRegionLocator in interface HConnection
    
    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: HConnection
    
    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. Note that HConnection needs to be unmanaged
    
    Specified by:
    
    getAdmin in interface Connection
    
    Specified by:
    
    getAdmin in interface HConnection
    
    Returns:
    an Admin instance for cluster administration
    
    Throws:
    
    IOException
  - getConnectionMetrics
```
public MetricsConnection getConnectionMetrics()
```
    Specified by:
    
    getConnectionMetrics in interface ClusterConnection
    
    Returns:
    the MetricsConnection instance associated with this connection.
  - getCurrentMetaLookupPool
```
protected ExecutorService getCurrentMetaLookupPool()
```
  - getCurrentBatchPool
```
protected ExecutorService getCurrentBatchPool()
```
  - toString
```
public String toString()
```
    An identifier that will remain the same for a given connection.
    
    Overrides:
    
    toString in class Object
  - getConfiguration
```
public org.apache.hadoop.conf.Configuration getConfiguration()
```
    Specified by:
    
    getConfiguration in interface Connection
    
    Specified by:
    
    getConfiguration in interface HConnection
    
    Returns:
    Configuration instance being used by this HConnection instance.
  - isMasterRunning
```
@Deprecated
public boolean isMasterRunning()
                        throws MasterNotRunningException,
                               ZooKeeperConnectionException
```
    Deprecated.
    
    Specified by:
    
    isMasterRunning in interface ClusterConnection
    
    Specified by:
    
    isMasterRunning in interface HConnection
    
    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
    
    Specified by:
    
    getRegionLocation in interface HConnection
    
    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
  - getRegionLocation
```
public HRegionLocation getRegionLocation(byte[] tableName,
                                byte[] row,
                                boolean reload)
                                  throws IOException
```
    Specified by:
    
    getRegionLocation in interface HConnection
    
    Throws:
    
    IOException
  - isTableEnabled
```
public boolean isTableEnabled(TableName tableName)
                       throws IOException
```
    Description copied from interface: HConnection
    
    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 HConnection
    
    Parameters:
    tableName - table name
    
    Returns:
    true if the table is enabled, false otherwise
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableEnabled
```
public boolean isTableEnabled(byte[] tableName)
                       throws IOException
```
    Specified by:
    
    isTableEnabled in interface HConnection
    
    Throws:
    
    IOException
  - isTableDisabled
```
public boolean isTableDisabled(TableName tableName)
                        throws IOException
```
    Specified by:
    
    isTableDisabled in interface HConnection
    
    Parameters:
    tableName - table name
    
    Returns:
    true if the table is disabled, false otherwise
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableDisabled
```
public boolean isTableDisabled(byte[] tableName)
                        throws IOException
```
    Specified by:
    
    isTableDisabled in interface HConnection
    
    Throws:
    
    IOException
  - isTableAvailable
```
public boolean isTableAvailable(TableName tableName)
                         throws IOException
```
    Specified by:
    
    isTableAvailable in interface HConnection
    
    Parameters:
    tableName - table name
    
    Returns:
    true if all regions of the table are available, false otherwise
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableAvailable
```
public boolean isTableAvailable(byte[] tableName)
                         throws IOException
```
    Specified by:
    
    isTableAvailable in interface HConnection
    
    Throws:
    
    IOException
  - isTableAvailable
```
public boolean isTableAvailable(TableName tableName,
                       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.
    
    Specified by:
    
    isTableAvailable in interface ClusterConnection
    
    Specified by:
    
    isTableAvailable in interface HConnection
    
    Parameters:
    tableName - tableName
    splitKeys - splitKeys used while creating table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableAvailable
```
public boolean isTableAvailable(byte[] tableName,
                       byte[][] splitKeys)
                         throws IOException
```
    Specified by:
    
    isTableAvailable in interface HConnection
    
    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
    
    Specified by:
    
    locateRegion in interface HConnection
    
    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
```
public boolean isDeadServer(ServerName sn)
```
    Specified by:
    
    isDeadServer in interface ClusterConnection
    
    Specified by:
    
    isDeadServer in interface HConnection
    
    Returns:
    true if the server is known as dead, false otherwise.
  - 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
    
    Specified by:
    
    locateRegions in interface HConnection
    
    Parameters:
    tableName - table to get regions of
    
    Returns:
    list of region locations for all regions of table
    
    Throws:
    
    IOException
  - locateRegions
```
public List<HRegionLocation> locateRegions(byte[] tableName)
                                    throws IOException
```
    Specified by:
    
    locateRegions in interface HConnection
    
    Throws:
    
    IOException
  - 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
    
    Specified by:
    
    locateRegions in interface HConnection
    
    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
  - locateRegions
```
public List<HRegionLocation> locateRegions(byte[] tableName,
                                  boolean useCache,
                                  boolean offlined)
                                    throws IOException
```
    Specified by:
    
    locateRegions in interface HConnection
    
    Throws:
    
    IOException
  - 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
    
    Specified by:
    
    locateRegion in interface HConnection
    
    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
  - locateRegion
```
public HRegionLocation locateRegion(byte[] tableName,
                           byte[] row)
                             throws IOException
```
    Specified by:
    
    locateRegion in interface HConnection
    
    Throws:
    
    IOException
  - 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
    
    Specified by:
    
    relocateRegion in interface HConnection
    
    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
  - relocateRegion
```
public HRegionLocation relocateRegion(byte[] tableName,
                             byte[] row)
                               throws IOException
```
    Specified by:
    
    relocateRegion in interface HConnection
    
    Throws:
    
    IOException
  - locateRegion
```
public RegionLocations locateRegion(TableName tableName,
                           byte[] row,
                           boolean useCache,
                           boolean retry)
                             throws IOException
```
    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
  - locateRegion
```
public RegionLocations locateRegion(TableName tableName,
                           byte[] row,
                           boolean useCache,
                           boolean retry,
                           int replicaId)
                             throws IOException
```
    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
  - 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
  - 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
    
    Specified by:
    
    clearCaches in interface HConnection
    
    Parameters:
    serverName - A server name
  - clearRegionCache
```
public void clearRegionCache()
```
    Description copied from interface: ClusterConnection
    
    Allows flushing the region cache.
    
    Specified by:
    
    clearRegionCache in interface ClusterConnection
    
    Specified by:
    
    clearRegionCache in interface HConnection
  - 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
    
    Specified by:
    
    clearRegionCache in interface HConnection
    
    Parameters:
    tableName - Name of the table whose regions we are to remove from cache.
  - clearRegionCache
```
public void clearRegionCache(byte[] tableName)
```
    Specified by:
    
    clearRegionCache in interface HConnection
  - getAdmin
```
public org.apache.hadoop.hbase.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
    
    Specified by:
    
    getAdmin in interface HConnection
    
    Returns:
    proxy for HRegionServer
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getAdmin
```
public org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface getAdmin(ServerName serverName,
                                                                                             boolean master)
                                                                                               throws IOException
```
    Description copied from interface: HConnection
    
    Establishes a connection to the region server at the specified address.
    
    Specified by:
    
    getAdmin in interface HConnection
    
    master - do we check if master is alive
    
    Returns:
    proxy for HRegionServer
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getMaster
```
public org.apache.hadoop.hbase.protobuf.generated.MasterProtos.MasterService.BlockingInterface getMaster()
                                                                                                  throws MasterNotRunningException
```
    Description copied from interface: ClusterConnection
    
    Returns a MasterKeepAliveConnection to the active master
    
    Specified by:
    
    getMaster in interface ClusterConnection
    
    Specified by:
    
    getMaster in interface HConnection
    
    Throws:
    
    MasterNotRunningException
  - getKeepAliveMasterService
```
public org.apache.hadoop.hbase.client.MasterKeepAliveConnection getKeepAliveMasterService()
                                                                                   throws MasterNotRunningException
```
    Description copied from interface: ClusterConnection
    
    This function allows HBaseAdmin and potentially others to get a shared MasterService connection.
    
    Specified by:
    
    getKeepAliveMasterService in interface ClusterConnection
    
    Specified by:
    
    getKeepAliveMasterService in interface HConnection
    
    Returns:
    The shared instance. Never returns null.
    
    Throws:
    
    MasterNotRunningException
  - deleteCachedRegionLocation
```
public void deleteCachedRegionLocation(HRegionLocation location)
```
    Description copied from interface: ClusterConnection
    
    Deletes cached locations for the specific region.
    
    Specified by:
    
    deleteCachedRegionLocation in interface ClusterConnection
    
    Specified by:
    
    deleteCachedRegionLocation in interface HConnection
    
    Parameters:
    location - The location object for the region, to be purged from cache.
  - updateCachedLocations
```
public void updateCachedLocations(TableName tableName,
                         byte[] rowkey,
                         Object exception,
                         HRegionLocation source)
```
    Specified by:
    
    updateCachedLocations in interface HConnection
  - 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
    
    Specified by:
    
    updateCachedLocations in interface HConnection
    
    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
  - updateCachedLocations
```
public void updateCachedLocations(byte[] tableName,
                         byte[] rowkey,
                         Object exception,
                         HRegionLocation source)
```
    Specified by:
    
    updateCachedLocations in interface HConnection
  - processBatch
```
@Deprecated
public void processBatch(List<? extends Row> list,
                           TableName tableName,
                           ExecutorService pool,
                           Object[] results)
                  throws IOException,
                         InterruptedException
```
    Deprecated.
    
    Description copied from interface: HConnection
    
    Process a mixed batch of Get, Put and Delete actions. All actions for a RegionServer are forwarded in one RPC call.
    
    Specified by:
    
    processBatch in interface HConnection
    
    Parameters:
    list - The collection of actions.
    tableName - Name of the hbase table
    pool - thread pool for parallel execution
    results - An empty array, same size as list. If an exception is thrown, you can test here for partial results, and to determine which actions processed successfully.
    
    Throws:
    
    IOException - if there are problems talking to META. Per-item exceptions are stored in the results array.
    
    InterruptedException
  - processBatch
```
@Deprecated
public void processBatch(List<? extends Row> list,
                           byte[] tableName,
                           ExecutorService pool,
                           Object[] results)
                  throws IOException,
                         InterruptedException
```
    Deprecated.
    
    Specified by:
    
    processBatch in interface HConnection
    
    Throws:
    
    IOException
    
    InterruptedException
  - processBatchCallback
```
@Deprecated
public <R> void processBatchCallback(List<? extends Row> list,
                                       TableName tableName,
                                       ExecutorService pool,
                                       Object[] results,
                                       Batch.Callback<R> callback)
                          throws IOException,
                                 InterruptedException
```
    Deprecated. since 0.96 - Use HTable.processBatchCallback(java.util.List<? extends org.apache.hadoop.hbase.client.Row>, java.lang.Object[], org.apache.hadoop.hbase.client.coprocessor.Batch.Callback<R>) instead
    
    Send the queries in parallel on the different region servers. Retries on failures. If the method returns it means that there is no error, and the 'results' array will contain no exception. On error, an exception is thrown, and the 'results' array will contain results and exceptions.
    
    Specified by:
    
    processBatchCallback in interface HConnection
    
    Throws:
    
    IOException
    
    InterruptedException
  - processBatchCallback
```
@Deprecated
public <R> void processBatchCallback(List<? extends Row> list,
                                       byte[] tableName,
                                       ExecutorService pool,
                                       Object[] results,
                                       Batch.Callback<R> callback)
                          throws IOException,
                                 InterruptedException
```
    Deprecated.
    
    Specified by:
    
    processBatchCallback in interface HConnection
    
    Throws:
    
    IOException
    
    InterruptedException
  - createAsyncProcess
```
protected org.apache.hadoop.hbase.client.AsyncProcess createAsyncProcess(org.apache.hadoop.conf.Configuration conf)
```
  - getAsyncProcess
```
public org.apache.hadoop.hbase.client.AsyncProcess getAsyncProcess()
```
    Specified by:
    
    getAsyncProcess in interface ClusterConnection
    
    Returns:
    Default AsyncProcess associated with this connection.
  - getStatisticsTracker
```
public ServerStatisticTracker getStatisticsTracker()
```
    Specified by:
    
    getStatisticsTracker in interface ClusterConnection
    
    Returns:
    the current statistics tracker associated with this connection
  - getBackoffPolicy
```
public ClientBackoffPolicy getBackoffPolicy()
```
    Specified by:
    
    getBackoffPolicy in interface ClusterConnection
    
    Returns:
    the configured client backoff policy
  - setRegionCachePrefetch
```
@Deprecated
public void setRegionCachePrefetch(TableName tableName,
                                     boolean enable)
```
    Deprecated.
    
    Specified by:
    
    setRegionCachePrefetch in interface HConnection
  - setRegionCachePrefetch
```
@Deprecated
public void setRegionCachePrefetch(byte[] tableName,
                                     boolean enable)
```
    Deprecated.
    
    Specified by:
    
    setRegionCachePrefetch in interface HConnection
  - getRegionCachePrefetch
```
@Deprecated
public boolean getRegionCachePrefetch(TableName tableName)
```
    Deprecated.
    
    Specified by:
    
    getRegionCachePrefetch in interface HConnection
  - getRegionCachePrefetch
```
@Deprecated
public boolean getRegionCachePrefetch(byte[] tableName)
```
    Deprecated.
    
    Specified by:
    
    getRegionCachePrefetch in interface HConnection
  - 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
    
    Specified by:
    
    isClosed in interface HConnection
    
    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
  - getCurrentNrHRS
```
public int getCurrentNrHRS()
                    throws IOException
```
    Specified by:
    
    getCurrentNrHRS in interface HConnection
    
    Returns:
    the number of region servers that are currently running
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - 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, regardless of what the current value of refCount is. Ideally, refCount should be zero at this point, which would be the case if all of its consumers close the connection. However, 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 HConnection 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
  - listTables
```
@Deprecated
public HTableDescriptor[] listTables()
                              throws IOException
```
    Deprecated. Use Admin.listTables() instead
    
    Description copied from interface: HConnection
    
    List all the userspace tables. In other words, scan the hbase:meta table.
    
    Specified by:
    
    listTables in interface HConnection
    
    Returns:
    - returns an array of HTableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getTableNames
```
@Deprecated
public String[] getTableNames()
                       throws IOException
```
    Deprecated. Use Admin.listTableNames() instead
    
    Specified by:
    
    getTableNames in interface HConnection
    
    Throws:
    
    IOException
  - listTableNames
```
@Deprecated
public TableName[] listTableNames()
                           throws IOException
```
    Deprecated. Use Admin.listTableNames() instead
    
    Specified by:
    
    listTableNames in interface HConnection
    
    Throws:
    
    IOException
  - getHTableDescriptorsByTableName
```
@Deprecated
public HTableDescriptor[] getHTableDescriptorsByTableName(List<TableName> tableNames)
                                                   throws IOException
```
    Deprecated. Use Admin.getTableDescriptorsByTableName(List) instead
    
    Specified by:
    
    getHTableDescriptorsByTableName in interface HConnection
    
    Parameters:
    tableNames - List of table names
    
    Returns:
    HTD[] table metadata
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getHTableDescriptors
```
@Deprecated
public HTableDescriptor[] getHTableDescriptors(List<String> names)
                                        throws IOException
```
    Deprecated. Use Admin.getTableDescriptorsByTableName(List) instead
    
    Specified by:
    
    getHTableDescriptors in interface HConnection
    
    Throws:
    
    IOException
  - getHTableDescriptor
```
@Deprecated
public HTableDescriptor getHTableDescriptor(TableName tableName)
                                     throws IOException
```
    Deprecated. Use Admin.getTableDescriptor(TableName) instead
    
    Connects to the master to get the table descriptor.
    
    Specified by:
    
    getHTableDescriptor in interface HConnection
    
    Parameters:
    tableName - table name
    
    Returns:
    table metadata
    
    Throws:
    
    IOException - if the connection to master fails or if the table is not found.
  - getHTableDescriptor
```
@Deprecated
public HTableDescriptor getHTableDescriptor(byte[] tableName)
                                     throws IOException
```
    Deprecated. Use Admin.getTableDescriptor(TableName) instead
    
    Specified by:
    
    getHTableDescriptor in interface HConnection
    
    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
    
    Returns:
    RpcRetryingCallerFactory
  - isManaged
```
public boolean isManaged()
```
    Specified by:
    
    isManaged in interface ClusterConnection
    
    Returns:
    true if this is a managed connection.
  - hasCellBlockSupport
```
public boolean hasCellBlockSupport()
```
    Specified by:
    
    hasCellBlockSupport in interface ClusterConnection
    
    Returns:
    true when this connection uses a Codec and so supports cell blocks.
  - getConnectionConfiguration
```
public ConnectionConfiguration getConnectionConfiguration()
```
    Specified by:
    
    getConnectionConfiguration in interface ClusterConnection
    
    Returns:
    a ConnectionConfiguration object holding parsed configuration values
  - getRpcRetryingCallerFactory
```
public RpcRetryingCallerFactory getRpcRetryingCallerFactory()
```
    Specified by:
    
    getRpcRetryingCallerFactory in interface ClusterConnection
    
    Returns:
    Connection's RpcRetryingCallerFactory instance
  - getRpcControllerFactory
```
public RpcControllerFactory getRpcControllerFactory()
```
    Specified by:
    
    getRpcControllerFactory in interface ClusterConnection
    
    Returns:
    Connection's RpcControllerFactory instance

Class CoprocessorHConnection

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

user

clusterId

Constructor Detail

CoprocessorHConnection

CoprocessorHConnection

CoprocessorHConnection

Method Detail

getConnectionForEnvironment

getClient

getNonceGenerator

getTable

getTable

getTable

getTable

getTable

getTable

getBufferedMutator

getBufferedMutator

getRegionLocator

getAdmin

getConnectionMetrics

getCurrentMetaLookupPool

getCurrentBatchPool

toString

getConfiguration

isMasterRunning

getRegionLocation

getRegionLocation

isTableEnabled

isTableEnabled

isTableDisabled

isTableDisabled

isTableAvailable

isTableAvailable

isTableAvailable

isTableAvailable

locateRegion

isDeadServer

locateRegions

locateRegions

locateRegions

locateRegions

locateRegion

locateRegion

relocateRegion

relocateRegion

relocateRegion

locateRegion

locateRegion

cacheLocation

clearRegionCache

clearCaches

clearRegionCache

clearRegionCache

clearRegionCache

getAdmin

getAdmin

getMaster

getKeepAliveMasterService

deleteCachedRegionLocation

updateCachedLocations

updateCachedLocations

updateCachedLocations

processBatch

processBatch

processBatchCallback

processBatchCallback

createAsyncProcess

getAsyncProcess

getStatisticsTracker

getBackoffPolicy

setRegionCachePrefetch

setRegionCachePrefetch