org.apache.hadoop.hbase.client

Class RpcRetryingCallerWithReadReplicas

java.lang.Object

org.apache.hadoop.hbase.client.RpcRetryingCallerWithReadReplicas

@InterfaceAudience.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 and Description
(package private) class	RpcRetryingCallerWithReadReplicas.ReplicaRegionServerCallable A RegionServerCallable that takes into account the replicas, i.e.

Field Summary

Fields

Modifier and Type	Field and Description
protected ClusterConnection	cConnection
protected org.apache.hadoop.conf.Configuration	conf
protected Get	get
private static org.slf4j.Logger	LOG
private int	operationTimeout
protected ExecutorService	pool
private int	retries
private RpcControllerFactory	rpcControllerFactory
private RpcRetryingCallerFactory	rpcRetryingCallerFactory
private int	rpcTimeout
protected TableName	tableName
protected int	timeBeforeReplicas

Constructor Summary

Constructors

Constructor and Description
RpcRetryingCallerWithReadReplicas(RpcControllerFactory rpcControllerFactory, TableName tableName, ClusterConnection cConnection, Get get, ExecutorService pool, int retries, int operationTimeout, int rpcTimeout, int timeBeforeReplicas)

Method Summary

Modifier and Type	Method and 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 Detail

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

Constructor Detail

RpcRetryingCallerWithReadReplicas

public RpcRetryingCallerWithReadReplicas(RpcControllerFactory rpcControllerFactory,
                                         TableName tableName,
                                         ClusterConnection cConnection,
                                         Get get,
                                         ExecutorService pool,
                                         int retries,
                                         int operationTimeout,
                                         int rpcTimeout,
                                         int timeBeforeReplicas)

Method Detail

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