AsyncProcess.AsyncRequestFutureImpl (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.client.AsyncProcess.AsyncRequestFutureImpl<CResult>

All Implemented Interfaces:

AsyncProcess.AsyncRequestFuture

Enclosing class:

AsyncProcess
```
protected class AsyncProcess.AsyncRequestFutureImpl<CResult>
extends Object
implements AsyncProcess.AsyncRequestFuture
```
The context, and return value, for a single submit/submitAll call. Note on how this class (one AP submit) works. Initially, all requests are split into groups by server; request is sent to each server in parallel; the RPC calls are not async so a thread per server is used. Every time some actions fail, regions/locations might have changed, so we re-group them by server and region again and send these groups in parallel too. The result, in case of retries, is a "tree" of threads, with parent exiting after scheduling children. This is why lots of code doesn't require any synchronization.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private class`	`AsyncProcess.AsyncRequestFutureImpl.ReplicaCallIssuingRunnable` Runnable (that can be submitted to thread pool) that waits for when it's time to issue replica calls, finds region replicas, groups the requests by replica and issues the calls (on separate threads, via sendMultiAction).
`private class`	`AsyncProcess.AsyncRequestFutureImpl.SingleServerRequestRunnable` Runnable (that can be submitted to thread pool) that submits MultiAction to a single server.

Field Summary

Fields
Modifier and Type	Field and Description
`private AtomicLong`	`actionsInProgress`
`private Batch.Callback<CResult>`	`callback`
`private Set<MultiServerCallable<Row>>`	`callsInProgress`
`private AsyncProcess.BatchErrors`	`errors`
`private ConnectionManager.ServerErrorTracker`	`errorsByServer`
`private boolean`	`hasAnyReplicaGets`
`private long`	`nonceGroup`
`private ExecutorService`	`pool`
`private int[]`	`replicaGetIndices` Indices of replica gets in results.
`private Object`	`replicaResultLock` The lock controls access to results.
`private Object[]`	`results` Result array.
`private TableName`	`tableName`

Constructor Summary

Constructors
Constructor and Description
`AsyncProcess.AsyncRequestFutureImpl(TableName tableName, List<Action<Row>> actions, long nonceGroup, ExecutorService pool, boolean needResults, Object[] results, Batch.Callback<CResult> callback)`

Method Summary

Methods
Modifier and Type	Method and Description
`private String`	`buildDetailedErrorMsg(String string, int index)`
`private String`	`createLog(int numAttempt, int failureCount, int replaySize, ServerName sn, Throwable error, long backOffTime, boolean willRetry, String startTime, int failed, int stopped)`
`private void`	`decActionCounter(int index)`
`private RegionLocations`	`findAllLocationsOrFail(Action<Row> action, boolean useCache)`
`(package private) long`	`getActionsInProgress()`
`private Long`	`getBackoff(ServerName server, byte[] regionName)`
`Set<MultiServerCallable<Row>>`	`getCallsInProgress()`
`RetriesExhaustedWithDetailsException`	`getErrors()`
`List<? extends Row>`	`getFailedOperations()`
`private Collection<? extends Runnable>`	`getNewMultiActionRunnable(ServerName server, MultiAction<Row> multiAction, int numAttempt)`
`private HRegionLocation`	`getReplicaLocationOrFail(Action<Row> action)`
`Object[]`	`getResults()`
`private void`	`groupAndSendMultiAction(List<Action<Row>> currentActions, int numAttempt)` Group a list of actions per region servers, and send them.
`boolean`	`hasError()`
`private boolean`	`isActionComplete(int index, Row row)` Checks if the action is complete; used on error to prevent needless retries.
`private void`	`logNoResubmit(ServerName oldServer, int numAttempt, int failureCount, Throwable throwable, int failed, int stopped)`
`AsyncProcess.Retry`	`manageError(int originalIndex, Row row, AsyncProcess.Retry canRetry, Throwable throwable, ServerName server)` Check that we can retry acts accordingly: logs, set the error status.
`private void`	`manageLocationError(Action<Row> action, Exception ex)`
`private void`	`receiveGlobalFailure(MultiAction<Row> rsActions, ServerName server, int numAttempt, Throwable t)` Resubmit all the actions from this multiaction after a failure.
`private void`	`receiveMultiAction(MultiAction<Row> multiAction, ServerName server, MultiResponse responses, int numAttempt)` Called when we receive the result of a server query.
`private void`	`resubmit(ServerName oldServer, List<Action<Row>> toReplay, int numAttempt, int failureCount, Throwable throwable)` Log as much info as possible, and, if there is something to replay, submit it again after a back off sleep.
`private void`	`sendMultiAction(Map<ServerName,MultiAction<Row>> actionsByServer, int numAttempt, List<Action<Row>> actionsForReplicaThread, boolean reuseThread)` Send a multi action structure to the servers, after a delay depending on the attempt number.
`private void`	`setError(int index, Row row, Throwable throwable, ServerName server)` Sets the error from a particular action.
`private void`	`setResult(Action<Row> action, Object result)` Sets the non-error result from a particular action.
`private void`	`startWaitingForReplicaCalls(List<Action<Row>> actionsForReplicaThread)` Starts waiting to issue replica calls on a different thread; or issues them immediately.
`private AsyncProcess.ReplicaResultState`	`trySetResultSimple(int index, Row row, boolean isError, Object result, ServerName server, boolean isFromReplica)` Tries to set the result or error for a particular action as if there were no replica calls.
`void`	`waitUntilDone()` Wait until all tasks are executed, successfully or not.
`private boolean`	`waitUntilDone(long cutoff)`

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

Field Detail
- callback
```
private final Batch.Callback<CResult> callback
```
- errors
```
private final AsyncProcess.BatchErrors errors
```
- errorsByServer
```
private final ConnectionManager.ServerErrorTracker errorsByServer
```
- pool
```
private final ExecutorService pool
```
- callsInProgress
```
private final Set<MultiServerCallable<Row>> callsInProgress
```
- tableName
```
private final TableName tableName
```
- actionsInProgress
```
private final AtomicLong actionsInProgress
```
- replicaResultLock
```
private final Object replicaResultLock
```
  The lock controls access to results. It is only held when populating results where there might be several callers (eventual consistency gets). For other requests, there's one unique call going on per result index.
- results
```
private final Object[] results
```
  Result array. Null if results are not needed. Otherwise, each index corresponds to the action index in initial actions submitted. For most request types, has null-s for requests that are not done, and result/exception for those that are done. For eventual-consistency gets, initially the same applies; at some point, replica calls might be started, and ReplicaResultState is put at the corresponding indices. The returning calls check the type to detect when this is the case. After all calls are done, ReplicaResultState-s are replaced with results for the user.
- replicaGetIndices
```
private final int[] replicaGetIndices
```
  Indices of replica gets in results. If null, all or no actions are replica-gets.
- hasAnyReplicaGets
```
private final boolean hasAnyReplicaGets
```
- nonceGroup
```
private final long nonceGroup
```

Constructor Detail

AsyncProcess.AsyncRequestFutureImpl

public AsyncProcess.AsyncRequestFutureImpl(TableName tableName,
                                   List<Action<Row>> actions,
                                   long nonceGroup,
                                   ExecutorService pool,
                                   boolean needResults,
                                   Object[] results,
                                   Batch.Callback<CResult> callback)

Method Detail

getActionsInProgress
```
long getActionsInProgress()
```

getCallsInProgress

public Set<MultiServerCallable<Row>> getCallsInProgress()

groupAndSendMultiAction
```
private void groupAndSendMultiAction(List<Action<Row>> currentActions,
                           int numAttempt)
```
Group a list of actions per region servers, and send them.

Parameters:
currentActions - - the list of row to submit
numAttempt - - the current numAttempt (first attempt is 1)

getReplicaLocationOrFail

private HRegionLocation getReplicaLocationOrFail(Action<Row> action)

manageLocationError

private void manageLocationError(Action<Row> action,
                       Exception ex)

findAllLocationsOrFail

private RegionLocations findAllLocationsOrFail(Action<Row> action,
                                     boolean useCache)

sendMultiAction
```
private void sendMultiAction(Map<ServerName,MultiAction<Row>> actionsByServer,
                   int numAttempt,
                   List<Action<Row>> actionsForReplicaThread,
                   boolean reuseThread)
```
Send a multi action structure to the servers, after a delay depending on the attempt number. Asynchronous.

Parameters:
actionsByServer - the actions structured by regions
numAttempt - the attempt number.
actionsForReplicaThread - original actions for replica thread; null on non-first call.

getNewMultiActionRunnable

private Collection<? extends Runnable> getNewMultiActionRunnable(ServerName server,
                                                       MultiAction<Row> multiAction,
                                                       int numAttempt)

getBackoff
```
private Long getBackoff(ServerName server,
              byte[] regionName)
```
Parameters:
server - server location where the target region is hosted
regionName - name of the region which we are going to write some data

Returns:
the amount of time the client should wait until it submit a request to the specified server and region

startWaitingForReplicaCalls
```
private void startWaitingForReplicaCalls(List<Action<Row>> actionsForReplicaThread)
```
Starts waiting to issue replica calls on a different thread; or issues them immediately.

manageError

public AsyncProcess.Retry manageError(int originalIndex,
                             Row row,
                             AsyncProcess.Retry canRetry,
                             Throwable throwable,
                             ServerName server)

Check that we can retry acts accordingly: logs, set the error status.

Parameters:: originalIndex - the position in the list sent; row - the row; canRetry - if false, we won't retry whatever the settings.; throwable - the throwable, if any (can be null); server - the location, if any (can be null)
Returns:: true if the action can be retried, false otherwise.

receiveGlobalFailure
```
private void receiveGlobalFailure(MultiAction<Row> rsActions,
                        ServerName server,
                        int numAttempt,
                        Throwable t)
```
Resubmit all the actions from this multiaction after a failure.

Parameters:
rsActions - the actions still to do from the initial list
server - the destination
numAttempt - the number of attempts so far
t - the throwable (if any) that caused the resubmit

resubmit

private void resubmit(ServerName oldServer,
            List<Action<Row>> toReplay,
            int numAttempt,
            int failureCount,
            Throwable throwable)

Log as much info as possible, and, if there is something to replay, submit it again after a back off sleep.

logNoResubmit

private void logNoResubmit(ServerName oldServer,
                 int numAttempt,
                 int failureCount,
                 Throwable throwable,
                 int failed,
                 int stopped)

receiveMultiAction

private void receiveMultiAction(MultiAction<Row> multiAction,
                      ServerName server,
                      MultiResponse responses,
                      int numAttempt)

Called when we receive the result of a server query.

Parameters:: multiAction - - the multiAction we sent; server - - the location. It's used as a server name.; responses - - the response, if any; numAttempt - - the attempt

createLog

private String createLog(int numAttempt,
               int failureCount,
               int replaySize,
               ServerName sn,
               Throwable error,
               long backOffTime,
               boolean willRetry,
               String startTime,
               int failed,
               int stopped)

setResult
```
private void setResult(Action<Row> action,
             Object result)
```
Sets the non-error result from a particular action.

Parameters:
action - Action (request) that the server responded to.
result - The result.

setError

private void setError(int index,
            Row row,
            Throwable throwable,
            ServerName server)

Sets the error from a particular action.

Parameters:: index - Original action index.; row - Original request.; throwable - The resulting error.; server - The source server.

isActionComplete
```
private boolean isActionComplete(int index,
                       Row row)
```
Checks if the action is complete; used on error to prevent needless retries. Does not synchronize, assuming element index/field accesses are atomic. This is an opportunistic optimization check, doesn't have to be strict.

Parameters:
index - Original action index.
row - Original request.

trySetResultSimple

private AsyncProcess.ReplicaResultState trySetResultSimple(int index,
                                                 Row row,
                                                 boolean isError,
                                                 Object result,
                                                 ServerName server,
                                                 boolean isFromReplica)

Tries to set the result or error for a particular action as if there were no replica calls.

Returns:: null if successful; replica state if there were in fact replica calls.

decActionCounter

private void decActionCounter(int index)

buildDetailedErrorMsg

private String buildDetailedErrorMsg(String string,
                           int index)

waitUntilDone
```
public void waitUntilDone()
                   throws InterruptedIOException
```
Description copied from interface: AsyncProcess.AsyncRequestFuture

Wait until all tasks are executed, successfully or not.

Specified by:

waitUntilDone in interface AsyncProcess.AsyncRequestFuture

Throws:

InterruptedIOException

waitUntilDone

private boolean waitUntilDone(long cutoff)
                       throws InterruptedException

Throws:: InterruptedException

hasError
```
public boolean hasError()
```
Specified by:

hasError in interface AsyncProcess.AsyncRequestFuture

getFailedOperations
```
public List<? extends Row> getFailedOperations()
```
Specified by:

getFailedOperations in interface AsyncProcess.AsyncRequestFuture

getErrors
```
public RetriesExhaustedWithDetailsException getErrors()
```
Specified by:

getErrors in interface AsyncProcess.AsyncRequestFuture

getResults
```
public Object[] getResults()
                    throws InterruptedIOException
```
Specified by:

getResults in interface AsyncProcess.AsyncRequestFuture

Throws:

InterruptedIOException

Class AsyncProcess.AsyncRequestFutureImpl<CResult>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

callback

errors

errorsByServer

pool

callsInProgress

tableName

actionsInProgress

replicaResultLock

results

replicaGetIndices

hasAnyReplicaGets

nonceGroup

Constructor Detail

AsyncProcess.AsyncRequestFutureImpl

Method Detail

getActionsInProgress

getCallsInProgress

groupAndSendMultiAction

getReplicaLocationOrFail

manageLocationError

findAllLocationsOrFail

sendMultiAction

getNewMultiActionRunnable

getBackoff

startWaitingForReplicaCalls

manageError

receiveGlobalFailure

resubmit

logNoResubmit

receiveMultiAction

createLog

setResult

setError

isActionComplete

trySetResultSimple

decActionCounter

buildDetailedErrorMsg

waitUntilDone

waitUntilDone

hasError

getFailedOperations

getErrors

getResults