Package org.apache.hadoop.hbase.client

Class RpcRetryingCallerWithReadReplicas

java.lang.Object

org.apache.hadoop.hbase.client.RpcRetryingCallerWithReadReplicas

@Private
public class RpcRetryingCallerWithReadReplicas
extends Object

Caller that goes to replica if the primary region does no answer within a configurable timeout. If the timeout is reached, it calls all the secondary replicas, and returns the first answer. If the answer comes from one of the secondary replica, it will be marked as stale.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) class	RpcRetryingCallerWithReadReplicas.ReplicaRegionServerCallable	A RegionServerCallable that takes into account the replicas, i.e.

Field Summary

Fields

Modifier and Type	Field	Description
protected final ClusterConnection	cConnection
protected final org.apache.hadoop.conf.Configuration	conf
protected final Get	get
private static final org.slf4j.Logger	LOG
private final int	operationTimeout
protected final ExecutorService	pool
private final Map<String,byte[]>	requestAttributes
private final int	retries
private final RpcControllerFactory	rpcControllerFactory
private final RpcRetryingCallerFactory	rpcRetryingCallerFactory
private final int	rpcTimeout
protected final TableName	tableName
protected final int	timeBeforeReplicas

Constructor Summary

Constructors

Constructor	Description
RpcRetryingCallerWithReadReplicas(RpcControllerFactory rpcControllerFactory, TableName tableName, ClusterConnection cConnection, Get get, ExecutorService pool, int retries, int operationTimeout, int rpcTimeout, int timeBeforeReplicas, Map<String,byte[]> requestAttributes)

Method Summary

Modifier and Type	Method	Description
private void	addCallsForReplica(ResultBoundedCompletionService<Result> cs, RegionLocations rl, int min, int max)	Creates the calls and submit them
Result	call(int operationTimeout)	Algo: - we put the query into the execution pool.
(package private) static RegionLocations	getRegionLocations(boolean useCache, int replicaId, ClusterConnection cConnection, TableName tableName, byte[] row)
(package private) static void	throwEnrichedException(ExecutionException e, int retries)	Extract the real exception from the ExecutionException, and throws what makes more sense.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

LOG

private static final org.slf4j.Logger LOG

pool

protected final ExecutorService pool

cConnection

protected final ClusterConnection cConnection

conf

protected final org.apache.hadoop.conf.Configuration conf

get

protected final Get get

tableName

protected final TableName tableName

timeBeforeReplicas

protected final int timeBeforeReplicas

operationTimeout

private final int operationTimeout

rpcTimeout

private final int rpcTimeout

retries

private final int retries

rpcControllerFactory

private final RpcControllerFactory rpcControllerFactory

rpcRetryingCallerFactory

private final RpcRetryingCallerFactory rpcRetryingCallerFactory

requestAttributes

private final Map<String,byte[]> requestAttributes

Constructor Details

RpcRetryingCallerWithReadReplicas

public RpcRetryingCallerWithReadReplicas(RpcControllerFactory rpcControllerFactory,
 TableName tableName,
 ClusterConnection cConnection,
 Get get,
 ExecutorService pool,
 int retries,
 int operationTimeout,
 int rpcTimeout,
 int timeBeforeReplicas,
 Map<String,byte[]> requestAttributes)

Method Details

call

public Result call(int operationTimeout)
            throws DoNotRetryIOException,
InterruptedIOException,
RetriesExhaustedException

Algo: - we put the query into the execution pool. - after x ms, if we don't have a result, we add the queries for the secondary replicas - we take the first answer - when done, we cancel what's left. Cancelling means: - removing from the pool if the actual call was not started - interrupting the call if it has started Client side, we need to take into account - a call is not executed immediately after being put into the pool - a call is a thread. Let's not multiply the number of thread by the number of replicas. Server side, if we can cancel when it's still in the handler pool, it's much better, as a call can take some i/o.

Globally, the number of retries, timeout and so on still applies, but it's per replica, not global. We continue until all retries are done, or all timeouts are exceeded.

Throws:

DoNotRetryIOException

InterruptedIOException

RetriesExhaustedException

throwEnrichedException

static void throwEnrichedException(ExecutionException e,
 int retries)
                            throws RetriesExhaustedException,
DoNotRetryIOException

Extract the real exception from the ExecutionException, and throws what makes more sense.

Throws:

RetriesExhaustedException

DoNotRetryIOException

addCallsForReplica

private void addCallsForReplica(ResultBoundedCompletionService<Result> cs,
 RegionLocations rl,
 int min,
 int max)

Creates the calls and submit them

Parameters:

cs - - the completion service to use for submitting

rl - - the region locations

min - - the id of the first replica, inclusive

max - - the id of the last replica, inclusive.

getRegionLocations

static RegionLocations getRegionLocations(boolean useCache,
 int replicaId,
 ClusterConnection cConnection,
 TableName tableName,
 byte[] row)
                                   throws RetriesExhaustedException,
DoNotRetryIOException,
InterruptedIOException

Throws:

RetriesExhaustedException

DoNotRetryIOException

InterruptedIOException