private RetryCapacity AddNewRetryCapacity(string serviceURL)
{
_rwlock.EnterUpgradeableReadLock();
try
{
if (!_serviceUrlToCapacityMap.TryGetValue(serviceURL, out RetryCapacity value))
{
_rwlock.EnterWriteLock();
try
{
value = new RetryCapacity(THROTTLE_RETRY_REQUEST_COST * THROTTLED_RETRIES);
_serviceUrlToCapacityMap.Add(serviceURL, value);
return(value);
}
finally
{
_rwlock.ExitWriteLock();
}
}
return(value);
}
finally
{
_rwlock.ExitUpgradeableReadLock();
}
}
private RetryCapacity AddNewRetryCapacity(string serviceURL)
{
RetryCapacity retryCapacity;
_rwlock.EnterUpgradeableReadLock();
try
{
if (!(_serviceUrlToCapacityMap.TryGetValue(serviceURL, out retryCapacity)))
{
_rwlock.EnterWriteLock();
try
{
retryCapacity = new RetryCapacity(THROTTLE_RETRY_REQUEST_COST * THROTTLED_RETRIES);
_serviceUrlToCapacityMap.Add(serviceURL, retryCapacity);
return(retryCapacity);
}
finally
{
_rwlock.ExitWriteLock();
}
}
else
{
return(retryCapacity);
}
}
finally
{
_rwlock.ExitUpgradeableReadLock();
}
}
private RetryCapacity AddNewRetryCapacity(string serviceURL)
{
RetryCapacity retryCapacity;
_rwlock.EnterUpgradeableReadLock();
try
{
if (!(_serviceUrlToCapacityMap.TryGetValue(serviceURL, out retryCapacity)))
{
_rwlock.EnterWriteLock();
try
{
retryCapacity = new RetryCapacity(retryCost * initialRetryTokens);
_serviceUrlToCapacityMap.Add(serviceURL, retryCapacity);
return(retryCapacity);
}
finally
{
_rwlock.ExitWriteLock();
}
}
else
{
return(retryCapacity);
}
}
finally
{
_rwlock.ExitUpgradeableReadLock();
}
}
/// <summary>
/// Constructor for DefaultRetryPolicy.
/// </summary>
/// <param name="config">The Client config object. This is used to
/// retrieve the maximum number of retries before throwing
/// back a exception(This does not count the initial request) and
/// the service URL for the request.</param>
public DefaultRetryPolicy(IClientConfig config)
{
this.MaxRetries = config.MaxErrorRetry;
if (config.ThrottleRetries)
{
string serviceURL = config.DetermineServiceURL();
_retryCapacity = _capacityManagerInstance.GetRetryCapacity(serviceURL);
}
}
/// <summary>
/// This method releases capacity back. This is invoked by the TryReleaseCapacity method.
/// </summary>
/// <param name="retryCapacity">Contains the RetryCapacity object for the said ServiceURL.</param>
/// <param name="capacity">The capacity that needs to be released based on whether it was a successful response or a successful retry response.</param>
private static void ReleaseCapacity(int capacity, RetryCapacity retryCapacity)
{
if (retryCapacity.AvailableCapacity >= 0 && retryCapacity.AvailableCapacity < retryCapacity.MaxCapacity)
{
lock (retryCapacity)
{
retryCapacity.AvailableCapacity = Math.Min((retryCapacity.AvailableCapacity + capacity), retryCapacity.MaxCapacity);
}
}
}
/// <summary>
/// This method calls a method to release capacity back
/// based on whether it was a successful response or a successful retry response. This is invoked by a retry request response.
/// </summary>
/// <param name="isRetryRequest">if this request is a retry, use a different capacity cost</param>
/// <param name="retryCapacity">Contains the RetryCapacity object for the said ServiceURL.</param>
public void TryReleaseCapacity(bool isRetryRequest, RetryCapacity retryCapacity)
{
if (isRetryRequest)
{
ReleaseCapacity(THROTTLE_RETRY_REQUEST_COST, retryCapacity);
}
else
{
ReleaseCapacity(THROTTLE_REQUEST_COST, retryCapacity);
}
}
/// <summary>
/// This method calls a method to release capacity back
/// based on whether it was a successful response or a successful retry response. This is invoked by a retry request response.
/// </summary>
/// <param name="retryCapacity">Contains the RetryCapacity object for the said ServiceURL.</param>
/// <param name="capacity">The capacity that needs to be released based on whether it was a successful response or a successful retry response.</returns>
public void TryReleaseCapacity(bool isRetryRequest,RetryCapacity retryCapacity)
{
if(isRetryRequest)
{
ReleaseCapacity(THROTTLE_RETRY_REQUEST_COST,retryCapacity);
}
else
{
ReleaseCapacity(THROTTLE_REQUEST_COST,retryCapacity);
}
}
public void AcquireCapacityInvalidUnitTest()
{
int throttleRetryCount = 0;
int throttleRetryCost = 5;
int throttleCost = 1;
CapacityManager capacityManagerInstance = new CapacityManager(throttleRetryCount, throttleRetryCost, throttleCost);
retryCapacity = capacityManagerInstance.GetRetryCapacity("AcquireCapacityInvalidUnitTest");
Assert.IsNotNull(retryCapacity);
Assert.IsFalse(capacityManagerInstance.TryAcquireCapacity(retryCapacity));
Assert.AreEqual(0, retryCapacity.AvailableCapacity);
var consumedCapacity = retryCapacity.MaxCapacity - retryCapacity.AvailableCapacity;
Assert.AreEqual(0, consumedCapacity);
}
private bool TryGetRetryCapacity(string key, out RetryCapacity value)
{
_rwlock.EnterReadLock();
try
{
if (_serviceUrlToCapacityMap.TryGetValue(key, out value))
{
return(true);
}
return(false);
}
finally
{
_rwlock.ExitReadLock();
}
}
public bool TryAcquireCapacity(RetryCapacity retryCapacity)
{
if (THROTTLE_RETRY_REQUEST_COST < 0)
{
return(false);
}
lock (retryCapacity)
{
if (retryCapacity.AvailableCapacity - THROTTLE_RETRY_REQUEST_COST >= 0)
{
retryCapacity.AvailableCapacity -= THROTTLE_RETRY_REQUEST_COST;
return(true);
}
return(false);
}
}
/// <summary>
/// This method acquires a said retry capacity if the container has the capacity.
/// </summary>
/// <param name="retryCapacity">Contains the RetryCapacity object for the said ServiceURL.</param>
/// <param name="capacity">The retry capacity that needs to be acquired for a retry request.</returns>
public bool TryAcquireCapacity(RetryCapacity retryCapacity)
{
if (THROTTLE_RETRY_REQUEST_COST < 0)
{
return false;
}
lock (retryCapacity)
{
if (retryCapacity.AvailableCapacity - THROTTLE_RETRY_REQUEST_COST >= 0)
{
retryCapacity.AvailableCapacity -= THROTTLE_RETRY_REQUEST_COST;
return true;
}
else
{
return false;
}
}
}
public void ReleaseCapacityUnitTest()
{
int throttleRetryCount = 5;
int throttleRetryCost = 5;
int throttleCost = 1;
CapacityManager capacityManagerInstance = new CapacityManager(throttleRetryCount, throttleRetryCost, throttleCost);
retryCapacity = capacityManagerInstance.GetRetryCapacity("ReleaseCapacityUnitTest");
Assert.IsNotNull(retryCapacity);
Assert.IsTrue(capacityManagerInstance.TryAcquireCapacity(retryCapacity));
capacityManagerInstance.TryReleaseCapacity(true, retryCapacity);
Assert.AreEqual(throttleRetryCost * throttleRetryCount, retryCapacity.AvailableCapacity);
var consumedCapacity = retryCapacity.MaxCapacity - retryCapacity.AvailableCapacity;
Assert.AreEqual(0, consumedCapacity);
capacityManagerInstance.TryReleaseCapacity(false, retryCapacity);
Assert.AreEqual(throttleRetryCost * throttleRetryCount, retryCapacity.AvailableCapacity);
consumedCapacity = retryCapacity.MaxCapacity - retryCapacity.AvailableCapacity;
Assert.AreEqual(0, consumedCapacity);
}
/// <summary>
/// This method calls a method to release capacity back
/// based on whether it was a successful response or a successful retry response. This is invoked by a retry request response.
/// </summary>
/// <param name="capacityType">Specifies what capacity type cost to use for adding capacity</param>
/// <param name="retryCapacity">Contains the RetryCapacity object for the said ServiceURL.</param>
public void ReleaseCapacity(CapacityType capacityType, RetryCapacity retryCapacity)
{
switch (capacityType)
{
case CapacityType.Retry:
ReleaseCapacity(retryCost, retryCapacity);
break;
case CapacityType.Timeout:
ReleaseCapacity(timeoutRetryCost, retryCapacity);
break;
case CapacityType.Increment:
ReleaseCapacity(noRetryIncrement, retryCapacity);
break;
default:
throw new NotSupportedException($"Unsupported CapacityType {capacityType}");
}
}
/// <summary>
/// This method acquires a said retry capacity if the container has the capacity.
/// </summary>
/// <param name="retryCapacity">Contains the RetryCapacity object for the said ServiceURL.</param>
/// <param name="capacityType">Specifies what capacity type cost to use for obtaining capacity</param>
public bool TryAcquireCapacity(RetryCapacity retryCapacity, CapacityType capacityType)
{
var capacityCost = capacityType == CapacityType.Timeout ? timeoutRetryCost : retryCost;
if (capacityCost < 0)
{
return(false);
}
lock (retryCapacity)
{
if (retryCapacity.AvailableCapacity - capacityCost >= 0)
{
retryCapacity.AvailableCapacity -= capacityCost;
return(true);
}
else
{
return(false);
}
}
}
private bool TryGetRetryCapacity(string key, out RetryCapacity value)
{
_rwlock.EnterReadLock();
try
{
if (_serviceUrlToCapacityMap.TryGetValue(key, out value))
{
return true;
}
return false;
}
finally
{
_rwlock.ExitReadLock();
}
}
private RetryCapacity AddNewRetryCapacity(string serviceURL)
{
RetryCapacity retryCapacity;
_rwlock.EnterUpgradeableReadLock();
try
{
if (!(_serviceUrlToCapacityMap.TryGetValue(serviceURL, out retryCapacity)))
{
_rwlock.EnterWriteLock();
try
{
retryCapacity = new RetryCapacity(THROTTLE_RETRY_REQUEST_COST * THROTTLED_RETRIES);
_serviceUrlToCapacityMap.Add(serviceURL, retryCapacity);
return retryCapacity;
}
finally
{
_rwlock.ExitWriteLock();
}
}
else
{
return retryCapacity;
}
}
finally
{
_rwlock.ExitUpgradeableReadLock();
}
}
/// <summary>
/// This method acquires a said retry capacity if the container has the capacity.
/// </summary>
/// <param name="retryCapacity">Contains the RetryCapacity object for the said ServiceURL.</param>
public bool TryAcquireCapacity(RetryCapacity retryCapacity)
{
return(TryAcquireCapacity(retryCapacity, CapacityType.Retry));
}
public void TryReleaseCapacity(bool isRetryRequest, RetryCapacity retryCapacity)
{
ReleaseCapacity(isRetryRequest ? CapacityType.Retry : CapacityType.Increment, retryCapacity);
}
/// <summary>
/// This method releases capacity back. This is invoked by the TryReleaseCapacity method.
/// </summary>
/// <param name="retryCapacity">Contains the RetryCapacity object for the said ServiceURL.</param>
/// <param name="capacity">The capacity that needs to be released based on whether it was a successful response or a successful retry response.</returns>
private static void ReleaseCapacity(int capacity, RetryCapacity retryCapacity)
{
if (retryCapacity.AvailableCapacity >= 0 && retryCapacity.AvailableCapacity < retryCapacity.MaxCapacity)
{
lock (retryCapacity)
{
retryCapacity.AvailableCapacity = Math.Min((retryCapacity.AvailableCapacity + capacity), retryCapacity.MaxCapacity);
}
}
}
