ServerNonceManager (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.regionserver.ServerNonceManager

```
@InterfaceAudience.Private
public class ServerNonceManager
extends Object
```
Implementation of nonce manager that stores nonces in a hash map and cleans them up after some time; if nonce group/client ID is supplied, nonces are stored by client ID.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private static class ServerNonceManager.OperationContext

Nested Classes
Modifier and Type	Class and Description
`private static class`	`ServerNonceManager.OperationContext`

Field Summary

Fields
Modifier and Type	Field and Description
`private int`	`conflictWaitIterationMs` The time to wait in an extremely unlikely case of a conflict with a running op.
`private int`	`deleteNonceGracePeriod`
`static String`	`HASH_NONCE_GRACE_PERIOD_KEY`
`private static org.apache.commons.logging.Log`	`LOG`
`private ConcurrentHashMap<NonceKey,ServerNonceManager.OperationContext>`	`nonces` Nonces.
`private static SimpleDateFormat`	`tsFormat`

Constructor Summary

Constructors
Constructor and Description

ServerNonceManager(org.apache.hadoop.conf.Configuration conf)

Constructors
Constructor and Description
`ServerNonceManager(org.apache.hadoop.conf.Configuration conf)`

Method Summary

Methods
Modifier and Type	Method and Description
`private void`	`cleanUpOldNonces()`
`ScheduledChore`	`createCleanupScheduledChore(Stoppable stoppable)` Creates a scheduled chore that is used to clean up old nonces.
`void`	`endOperation(long group, long nonce, boolean success)` Ends the operation started by startOperation.
`void`	`reportOperationFromWal(long group, long nonce, long writeTime)` Reports the operation from WAL during replay.
`void`	`setConflictWaitIterationMs(int conflictWaitIterationMs)`
`boolean`	`startOperation(long group, long nonce, Stoppable stoppable)` Starts the operation if operation with such nonce has not already succeeded.

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

- Field Detail
  - HASH_NONCE_GRACE_PERIOD_KEY
```
public static final String HASH_NONCE_GRACE_PERIOD_KEY
```
    See Also:
    Constant Field Values
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - conflictWaitIterationMs
```
private int conflictWaitIterationMs
```
    The time to wait in an extremely unlikely case of a conflict with a running op. Only here so that tests could override it and not wait.
  - tsFormat
```
private static final SimpleDateFormat tsFormat
```
  - nonces
```
private ConcurrentHashMap<NonceKey,ServerNonceManager.OperationContext> nonces
```
    Nonces. Approximate overhead per nonce: 64 bytes from hashmap, 32 from two objects (k/v), NK: 16 bytes (2 longs), OC: 8 bytes (1 long) - so, 120 bytes. With 30min expiration time, 5k increments/appends per sec., we'd use approximately 1Gb, which is a realistic worst case. If it's much worse, we could use some sort of memory limit and cleanup.
  - deleteNonceGracePeriod
```
private int deleteNonceGracePeriod
```
- Constructor Detail
  - ServerNonceManager
```
public ServerNonceManager(org.apache.hadoop.conf.Configuration conf)
```
- Method Detail
  - setConflictWaitIterationMs
```
public void setConflictWaitIterationMs(int conflictWaitIterationMs)
```
  - startOperation
```
public boolean startOperation(long group,
                     long nonce,
                     Stoppable stoppable)
                       throws InterruptedException
```
    Starts the operation if operation with such nonce has not already succeeded. If the operation is in progress, waits for it to end and checks whether it has succeeded.
    
    Parameters:
    group - Nonce group.
    nonce - Nonce.
    stoppable - Stoppable that terminates waiting (if any) when the server is stopped.
    
    Returns:
    true if the operation has not already succeeded and can proceed; false otherwise.
    
    Throws:
    
    InterruptedException
  - endOperation
```
public void endOperation(long group,
                long nonce,
                boolean success)
```
    Ends the operation started by startOperation.
    
    Parameters:
    group - Nonce group.
    nonce - Nonce.
    success - Whether the operation has succeeded.
  - reportOperationFromWal
```
public void reportOperationFromWal(long group,
                          long nonce,
                          long writeTime)
```
    Reports the operation from WAL during replay.
    
    Parameters:
    group - Nonce group.
    nonce - Nonce.
    writeTime - Entry write time, used to ignore entries that are too old.
  - createCleanupScheduledChore
```
public ScheduledChore createCleanupScheduledChore(Stoppable stoppable)
```
    Creates a scheduled chore that is used to clean up old nonces.
    
    Parameters:
    stoppable - Stoppable for the chore.
    
    Returns:
    ScheduledChore; the scheduled chore is not started.
  - cleanUpOldNonces
```
private void cleanUpOldNonces()
```

Class ServerNonceManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

HASH_NONCE_GRACE_PERIOD_KEY

LOG

conflictWaitIterationMs

tsFormat

nonces

deleteNonceGracePeriod

Constructor Detail

ServerNonceManager

Method Detail

setConflictWaitIterationMs

startOperation

endOperation

reportOperationFromWal

createCleanupScheduledChore

cleanUpOldNonces