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); } } }