ExponentialDelayStrategy (AMPS Java Client (5.3.2.1.6d15937f.540279))

java.lang.Object
- com.crankuptheamps.client.ExponentialDelayStrategy

All Implemented Interfaces:

ReconnectDelayStrategy
```
public class ExponentialDelayStrategy
extends java.lang.Object
implements ReconnectDelayStrategy
```
ExponentialDelayStrategy is an implementation that exponentially "backs off" when reconnecting to the same server, with a maximum number of retries before it gives up entirely.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ExponentialDelayStrategy.MaximumRetryExceeded` A specialized exception type thrown by ExponentialDelayStrategy to indicate that the client should "give up" on attempting to reconnect to a server.

Field Summary

Fields
Modifier and Type	Field and Description
`protected double`	`_backoffExponent`
`protected int`	`_currentDelay`
`protected java.lang.String`	`_firstUri`
`protected int`	`_initialDelay`
`protected double`	`_jitter`
`protected java.lang.String`	`_lastUri`
`protected int`	`_maximumDelay`
`protected int`	`_maximumRetryTime`
`protected long`	`_startTime`
`static double`	`DEFAULT_BACKOFF_EXPONENT` The default exponent to use for calculating the next delay time.
`static int`	`DEFAULT_DELAY` The default time (in milliseconds) to wait before reconnecting to a server for the first time after a failed connection.
`static double`	`DEFAULT_JITTER` The amount of 'jitter' to apply when calculating a delay time, measured in multiples of the initial delay.
`static int`	`DEFAULT_MAXIMUM_DELAY` The default maximum time to wait between any reconnection attempts.
`static int`	`DEFAULT_MAXIMUM_RETRY_TIME` The default time (in millseconds) to allow reconnect attempts to continue without a successful connection, before "giving up" and abandoning the connection attempt.

Constructor Summary

Constructors
Constructor and Description

ExponentialDelayStrategy()
Constructs an ExponentialDelayStrategy, the default strategy for HAClient, using the default values for the class.

Constructors
Constructor and Description
`ExponentialDelayStrategy()` Constructs an ExponentialDelayStrategy, the default strategy for HAClient, using the default values for the class.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected int`	`_currentDurationAndIncrease()` Returns the _currentDelay, and also expands _currentDelay based on the configured exponent and maximum.
`protected void`	`_throwIfMaximumExceeded()` An internal function used to check if the configured retry has been exceeded, and if so, throw MaximumRetryExceeded to cause the calling HAClient to give up on reconnecting to a server.
`int`	`getConnectWaitDuration(java.lang.String uri_)` Returns the time (in milliseconds) that the client should wait before connecting to the given server URI.
`void`	`reset()` Reset the state of this reconnect delay.
`ExponentialDelayStrategy`	`setBackoffExponent(double exponent_)` Sets the exponent to use for calculating the next delay time.
`ExponentialDelayStrategy`	`setInitialDelay(int initialDelay_)` Sets the time (in milliseconds) to wait before reconnecting to a server for the first time after a failed connection.
`ExponentialDelayStrategy`	`setJitter(double jitter_)` Sets the jitter factor used to add randomness to the delay time.
`ExponentialDelayStrategy`	`setMaximumDelay(int maximumDelay_)` Sets the maximum time to wait between any reconnection attempts.
`ExponentialDelayStrategy`	`setMaximumRetryTime(int maximumRetryTime_)` Sets the time (in millseconds) to allow reconnect attempts to continue without a successful connection, before "giving up" and abandoning the connection attempt.

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

- Field Detail
  - DEFAULT_DELAY
```
public static final int DEFAULT_DELAY
```
    The default time (in milliseconds) to wait before reconnecting to a server for the first time after a failed connection.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_MAXIMUM_DELAY
```
public static final int DEFAULT_MAXIMUM_DELAY
```
    The default maximum time to wait between any reconnection attempts. Exponential backoff will not exceed this maximum.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_BACKOFF_EXPONENT
```
public static final double DEFAULT_BACKOFF_EXPONENT
```
    The default exponent to use for calculating the next delay time. For example if the initial time is 200ms and the exponent is 2.0, the next delay will be 400ms, then 800ms, etc.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_MAXIMUM_RETRY_TIME
```
public static final int DEFAULT_MAXIMUM_RETRY_TIME
```
    The default time (in millseconds) to allow reconnect attempts to continue without a successful connection, before "giving up" and abandoning the connection attempt. 0 means never give up.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_JITTER
```
public static final double DEFAULT_JITTER
```
    The amount of 'jitter' to apply when calculating a delay time, measured in multiples of the initial delay. Jitter is used to reduce the number of simultaneous reconnects that may be issued from multiple clients.
    
    See Also:
    
    Constant Field Values
  - _initialDelay
```
protected int _initialDelay
```
  - _maximumDelay
```
protected int _maximumDelay
```
  - _backoffExponent
```
protected double _backoffExponent
```
  - _maximumRetryTime
```
protected int _maximumRetryTime
```
  - _jitter
```
protected double _jitter
```
  - _currentDelay
```
protected int _currentDelay
```
  - _lastUri
```
protected java.lang.String _lastUri
```
  - _firstUri
```
protected java.lang.String _firstUri
```
  - _startTime
```
protected long _startTime
```
- Constructor Detail
  - ExponentialDelayStrategy
```
public ExponentialDelayStrategy()
```
    Constructs an ExponentialDelayStrategy, the default strategy for HAClient, using the default values for the class. For example, when constructed, the new object will use the DEFAULT_DELAY (200 ms) as the initial delay, the DEFAULT_BACKOFF_EXPONENT (2.0) as the backoff exponent, the DEFAULT_MAXIMUM_RETRY_TIME (0 -- never time out) as the maximum retry time, and so on. You can use the setters provided on the class to adjust these settings.
- Method Detail
  - setInitialDelay
```
public ExponentialDelayStrategy setInitialDelay(int initialDelay_)
```
    Sets the time (in milliseconds) to wait before reconnecting to a server for the first time after a failed connection.
    
    Parameters:
    
    initialDelay_ - The new initial delay value, in milliseconds.
    
    Returns:
    
    Self.
  - setMaximumDelay
```
public ExponentialDelayStrategy setMaximumDelay(int maximumDelay_)
```
    Sets the maximum time to wait between any reconnection attempts. Exponential backoff will not exceed this maximum.
    
    Parameters:
    
    maximumDelay_ - The new maximum delay value, in milliseconds.
    
    Returns:
    
    Self.
  - setBackoffExponent
```
public ExponentialDelayStrategy setBackoffExponent(double exponent_)
```
    Sets the exponent to use for calculating the next delay time. For example if the initial time is 200ms and the exponent is 2.0, the next delay will be 400ms, then 800ms, etc.
    
    Parameters:
    
    exponent_ - The new exponent value.
    
    Returns:
    
    Self.
  - setMaximumRetryTime
```
public ExponentialDelayStrategy setMaximumRetryTime(int maximumRetryTime_)
```
    Sets the time (in millseconds) to allow reconnect attempts to continue without a successful connection, before "giving up" and abandoning the connection attempt. 0 means never give up.
    
    Parameters:
    
    maximumRetryTime_ - The new maximum retry time, in milliseconds.
    
    Returns:
    
    Self.
  - setJitter
```
public ExponentialDelayStrategy setJitter(double jitter_)
```
    Sets the jitter factor used to add randomness to the delay time. Jitter is represented as a multiple of the initial delay time; a random number from [0, (JITTER * INITIAL_DELAY) ) is added to nonzero time delays.
    
    Parameters:
    
    jitter_ - The jitter factor, in multiples of the initial delay.
    
    Returns:
    
    self.
  - getConnectWaitDuration
```
public int getConnectWaitDuration(java.lang.String uri_)
                           throws java.lang.Exception
```
    Description copied from interface: ReconnectDelayStrategy
    
    Returns the time (in milliseconds) that the client should wait before connecting to the given server URI.
    
    Specified by:
    
    getConnectWaitDuration in interface ReconnectDelayStrategy
    
    Parameters:
    
    uri_ - The URI to which the client plans to connect.
    
    Returns:
    
    The time, in milliseconds, which the client should delay before connecting to uri_.
    
    Throws:
    
    java.lang.Exception - Any exception thrown indicates no connection should be attempted; the client in essence should "give up."
  - reset
```
public void reset()
```
    Description copied from interface: ReconnectDelayStrategy
    
    Reset the state of this reconnect delay. AMPS calls this method when a connection is successfully established.
    
    Specified by:
    
    reset in interface ReconnectDelayStrategy
  - _throwIfMaximumExceeded
```
protected void _throwIfMaximumExceeded()
                                throws ExponentialDelayStrategy.MaximumRetryExceeded
```
    An internal function used to check if the configured retry has been exceeded, and if so, throw MaximumRetryExceeded to cause the calling HAClient to give up on reconnecting to a server.
    
    Throws:
    
    ExponentialDelayStrategy.MaximumRetryExceeded - The configured maximum retry time has been exceeded.
  - _currentDurationAndIncrease
```
protected int _currentDurationAndIncrease()
                                   throws ExponentialDelayStrategy.MaximumRetryExceeded
```
    Returns the _currentDelay, and also expands _currentDelay based on the configured exponent and maximum.
    
    Returns:
    
    The delay that should be used, prior to increasing it.
    
    Throws:
    
    ExponentialDelayStrategy.MaximumRetryExceeded - The configured maximum retry time has been exceeded.

Class ExponentialDelayStrategy

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_DELAY

DEFAULT_MAXIMUM_DELAY

DEFAULT_BACKOFF_EXPONENT

DEFAULT_MAXIMUM_RETRY_TIME

DEFAULT_JITTER

_initialDelay

_maximumDelay

_backoffExponent

_maximumRetryTime

_jitter

_currentDelay

_lastUri

_firstUri

_startTime

Constructor Detail

ExponentialDelayStrategy

Method Detail

setInitialDelay

setMaximumDelay

setBackoffExponent

setMaximumRetryTime

setJitter

getConnectWaitDuration

reset

_throwIfMaximumExceeded

_currentDurationAndIncrease