public FullyThrottledTokenBucket(ITokenBucket oldBucket) { if (oldBucket != null) { this.pendingCharges = oldBucket.PendingCharges; } }
// Token: 0x060002F7 RID: 759 RVA: 0x0000F8AC File Offset: 0x0000DAAC BackOffValue IAirSyncUser.GetBudgetBackOffValue() { BackOffValue backOffValue = null; if (((IAirSyncUser)this).Budget != null) { ITokenBucket budgetTokenBucket = ((IAirSyncUser)this).GetBudgetTokenBucket(); if (budgetTokenBucket == null) { AirSyncDiagnostics.TraceInfo(ExTraceGlobals.RequestsTracer, null, "[AirSyncUser.GetBudgetBackOffDuration] Budget does not contain a token bucket. Likely unthrottled."); return(BackOffValue.NoBackOffValue); } float balance = budgetTokenBucket.GetBalance(); AirSyncDiagnostics.TraceInfo <float, int>(ExTraceGlobals.RequestsTracer, null, "[AirSyncUser.GetBudgetBackOffDuration]. Balance :{0}, RechargeRate:{1}", balance, budgetTokenBucket.RechargeRate); backOffValue = new BackOffValue { BackOffReason = "Budget" }; if ((double)balance < GlobalSettings.BudgetBackOffMinThreshold.TotalMilliseconds) { backOffValue.BackOffDuration = Math.Ceiling((GlobalSettings.BudgetBackOffMinThreshold.TotalMilliseconds - (double)balance) * 60.0 * 60.0 / (double)budgetTokenBucket.RechargeRate); backOffValue.BackOffType = ((balance > (float)(ulong.MaxValue * (ulong)((IAirSyncUser)this).Budget.ThrottlingPolicy.EasMaxBurst.Value)) ? BackOffType.Medium : BackOffType.High); } else { backOffValue.BackOffDuration = Math.Ceiling((GlobalSettings.BudgetBackOffMinThreshold.TotalMilliseconds - (double)balance) / 1000.0); } } AirSyncDiagnostics.TraceInfo <double, BackOffType>(ExTraceGlobals.RequestsTracer, null, "[AirSyncUser.GetBudgetBackOffDuration]. BudgetBackOff Duration:{0} sec. BackOffType:{1}", backOffValue.BackOffDuration, backOffValue.BackOffType); return(backOffValue ?? BackOffValue.NoBackOffValue); }
public OAuthClient(string clientId, string clientSecret, string region, ITokenBucket tokenBucket) : base($"https://{region}.battle.net", tokenBucket) { var credentials = Encoding.ASCII.GetBytes($"{clientId}:{clientSecret}"); Client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(credentials)); AddParameter("grant_type", "client_credentials"); }
public void SetUp() { _refillStrategy = new MockRefillStrategy(); _sleepStrategy = new Mock <ISleepStrategy>(); _bucket = TokenBuckets.Construct() .WithCapacity(Capacity) .WithRefillStrategy(_refillStrategy) .WithSleepStrategy(_sleepStrategy.Object) .Build(); }
public WorkflowController(ILogger <WorkflowController> logger, IPersistenceProvider persistenceProvider, IWorkflowRegistry registry, ITokenBucket tokenBucket) { _persistenceProvider = persistenceProvider; _logger = logger; _registry = registry; _tokenBucket = tokenBucket; }
private TokenBucket(ITokenBucket oldBucket, Unlimited <uint> maxBalance, Unlimited <uint> rechargeRate, Unlimited <uint> minBalance, BudgetKey budgetKey) { this.BudgetKey = budgetKey; this.LastUpdateUtc = TimeProvider.UtcNow; this.UpdateSettings(maxBalance, rechargeRate, minBalance); this.balance = (maxBalance.IsUnlimited ? 2147483647U : maxBalance.Value); if (oldBucket != null) { this.PendingCharges = oldBucket.PendingCharges; } }
protected HttpClientBase(string baseAddress, ITokenBucket tokenBucket) { _tokenBucket = tokenBucket; Client = new HttpClient { BaseAddress = new Uri(baseAddress) }; Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); _parameters = new Dictionary <string, string>(); }
/// <summary> /// Checks if the buckets have the same tick span and total limit. Returns true if both buckets /// are null. /// </summary> /// <param name="a">Token bucket A. May be null.</param> /// <param name="b">Token bucket B. May be null.</param> /// <returns>True if equivalent, false otherwise.</returns> public static bool AreEquivalent(ITokenBucket a, ITokenBucket b) { if (a == b) { return(true); } if (a == null || b == null) { return(false); } return(a.GetTickSpan() == b.GetTickSpan() && a.GetTotalLimit() == b.GetTotalLimit()); }
// Token: 0x060002FB RID: 763 RVA: 0x0000FAF8 File Offset: 0x0000DCF8 void IAirSyncUser.SetBudgetDiagnosticValues(bool start) { ITokenBucket budgetTokenBucket = ((IAirSyncUser)this).GetBudgetTokenBucket(); if (budgetTokenBucket != null) { float balance = budgetTokenBucket.GetBalance(); this.context.SetDiagnosticValue(start ? ConditionalHandlerSchema.BudgetBalanceStart : ConditionalHandlerSchema.BudgetBalanceEnd, balance); this.context.SetDiagnosticValue(start ? ConditionalHandlerSchema.IsOverBudgetAtStart : ConditionalHandlerSchema.IsOverBudgetAtEnd, balance < 0f); } StandardBudgetWrapper standardBudgetWrapper = ((IAirSyncUser)this).Budget as StandardBudgetWrapper; if (standardBudgetWrapper != null) { this.context.SetDiagnosticValue(start ? ConditionalHandlerSchema.ConcurrencyStart : ConditionalHandlerSchema.ConcurrencyEnd, standardBudgetWrapper.GetInnerBudget().Connections); } }
public static ITokenBucket Create(ITokenBucket tokenBucket, Unlimited <uint> maxBalance, Unlimited <uint> rechargeRate, Unlimited <uint> minBalance, BudgetKey budgetKey) { if (rechargeRate == 0U) { return(new FullyThrottledTokenBucket(tokenBucket)); } if (rechargeRate == 2147483647U || rechargeRate.IsUnlimited) { return(new UnthrottledTokenBucket(tokenBucket)); } TokenBucket tokenBucket2 = tokenBucket as TokenBucket; if (tokenBucket2 != null && tokenBucket2.BudgetKey == budgetKey) { tokenBucket2.UpdateSettings(maxBalance, rechargeRate, minBalance); return(tokenBucket); } return(new TokenBucket(tokenBucket, maxBalance, rechargeRate, minBalance, budgetKey)); }
static void Main(string[] args) { // Create a token bucket with a capacity of 1 token that refills at a fixed interval of 1 token/sec. ITokenBucket bucket = TokenBuckets.Construct() .WithCapacity(100) .WithFixedIntervalRefillStrategy(100, TimeSpan.FromSeconds(1)) .Build(); // ... while (true) { // Consume a token from the token bucket. If a token is not available this method will block until // the refill strategy adds one to the bucket. bucket.Consume(1); Poll(); } }
public void Add(Host host, LimitRule rule) { ITokenBucket ulBucket = null; ITokenBucket dlBucket = null; Remove(host); host.SetLimitRule(rule); if (rule.IsUploadLimited && !rule.IsUploadBlocked) { ulBucket = TokenBuckets.Construct() .WithCapacity(rule.UploadRate.Value + (rule.UploadBurst ?? NetworkUtilities.GetDefaultBurst(rule.UploadRate.Value))) .WithFixedIntervalRefillStrategy(rule.UploadRate.Value, TimeSpan.FromSeconds(1)) .Build(); } if (rule.IsDownloadLimited && !rule.IsDownloadBlocked) { dlBucket = TokenBuckets.Construct() .WithCapacity(rule.DownloadRate.Value + (rule.DownloadBurst ?? NetworkUtilities.GetDefaultBurst(rule.DownloadRate.Value))) .WithFixedIntervalRefillStrategy(rule.DownloadRate.Value, TimeSpan.FromSeconds(1)) .Build(); } if (ulBucket == null && dlBucket == null && !host.LimitRule.IsUploadBlocked && !host.LimitRule.IsDownloadBlocked) { return; } var buckets = new Tuple <ITokenBucket, ITokenBucket>(ulBucket, dlBucket); lock (_hostBucketDictLock) lock (_ipHostDict) lock (_bandwidthUploadDictLock) lock (_bandwidthDownloadDictLock) { _hostBucketDict.Add(host, buckets); _ipHostDict.Add(IPAddress.Parse(host.IpAddress.ToString()), host); _bandwidthUploadDict.Add(host, 0); _bandwidthDownloadDict.Add(host, 0); } }
private async Task <TResponse> ExecuteThrottledAsync(CustomerThrottle customerThrottle, TRequest request, CancellationToken cancellationTokenToCheckInternally, CancellationToken cancellationTokenToPassToDelegate) { ITokenBucket tokenBucket = null; if (customerThrottle.MaximumRequestsPerSecond > 0) { tokenBucket = await RetrieveMatchingTokenBucketContextOrMakeNew(customerThrottle).ConfigureAwait(false); if (cancellationTokenToCheckInternally.IsNotNone()) { cancellationTokenToCheckInternally.ThrowIfCancellationRequested(); } await tokenBucket.WaitConsumeAsync(1, cancellationTokenToCheckInternally).ConfigureAwait(false); } if (cancellationTokenToCheckInternally.IsNotNone()) { cancellationTokenToCheckInternally.ThrowIfCancellationRequested(); } return(await delegateFunction(request, cancellationTokenToPassToDelegate).ConfigureAwait(false)); }
/// <summary> /// Initializes a new instance of <see cref="AlgorithmTimeLimitManager"/> to manage the /// creation of <see cref="IsolatorLimitResult"/> instances as it pertains to the /// algorithm manager's time loop /// </summary> /// <param name="additionalTimeBucket">Provides a bucket of additional time that can be requested to be /// spent to give execution time for things such as training scheduled events</param> /// <param name="timeLoopMaximum">Specifies the maximum amount of time the algorithm is permitted to /// spend in a single time loop. This value can be overriden if certain actions are taken by the /// algorithm, such as invoking the training methods.</param> public AlgorithmTimeLimitManager(ITokenBucket additionalTimeBucket, TimeSpan timeLoopMaximum) { _timeLoopMaximum = timeLoopMaximum; AdditionalTimeBucket = additionalTimeBucket; _currentTimeStepTime = new ReferenceWrapper <DateTime>(DateTime.MinValue); }
/// <summary> /// Start stream. /// </summary> public void Start() { lock (this.SyncRoot) { if (_playlistSubscriberStream.State != State.UNINIT) throw new IllegalStateException(); _playlistSubscriberStream.State = State.STOPPED; if (_msgOut == null) { _msgOut = _consumerService.GetConsumerOutput(_playlistSubscriberStream); _msgOut.Subscribe(this, null); } _audioBucket = _bwController.GetAudioBucket(_bwContext); _videoBucket = _bwController.GetVideoBucket(_bwContext); } }
public CharacterEndpoint(ITokenBucket tokenBucket) : base(tokenBucket) { }
public void Available(ITokenBucket bucket, long tokenCount) { lock (this.SyncRoot) { _waitingForToken = false; _checkBandwidth = false; try { PullAndPush(); } catch (Exception ex) { log.Error("Error while pulling message.", ex); } _checkBandwidth = true; } }
public void Reset(ITokenBucket bucket, long tokenCount) { _waitingForToken = false; }
public RequestLimitService(ITokenBucket tokenBucket, IResourceRepository resourceRepository, ILimitRuleFilter limitRuleFilter) { _tokenBucket = tokenBucket; _resourceRepository = resourceRepository; _limitRuleFilter = limitRuleFilter; }
public SeasonEndpoint(ITokenBucket tokenBucket) : base(tokenBucket) { }
public UnthrottledTokenBucket(ITokenBucket oldBucket) { this.pendingCharges = ((oldBucket == null) ? 0 : oldBucket.PendingCharges); }
public ProfileEndpoint(ITokenBucket tokenBucket) : base(tokenBucket) { }
public async Task SetUp() { _refillStrategy = new MockRefillStrategy(); _bucket = await TokenBuckets.BucketWithRefillStrategy(Capacity, _refillStrategy).ConfigureAwait(false); }
public static string ToLimitString(this ITokenBucket b) { return(b.GetTotalLimit() + ":" + (b.GetTickSpan() / TimeSpan.TicksPerSecond)); }
public ActEndpoint(ITokenBucket tokenBucket) : base(tokenBucket) { }
protected Endpoint(ITokenBucket tokenBucket) { _tokenBucket = tokenBucket; }
public FollowerEndpoint(ITokenBucket tokenBucket) : base(tokenBucket) { }
public BattleNetClient(string accessToken, string region, string localization, ITokenBucket tokenBucket) : base($"https://{region}.api.blizzard.com", tokenBucket) { AddParameter("access_token", accessToken); AddParameter("locale", localization); }
/// <summary> /// Initializes a new instance of <see cref="AlgorithmTimeLimitManager"/> to manage the /// creation of <see cref="IsolatorLimitResult"/> instances as it pertains to the /// algorithm manager's time loop /// </summary> /// <param name="additionalTimeBucket">Provides a bucket of additional time that can be requested to be /// spent to give execution time for things such as training scheduled events</param> /// <param name="timeLoopMaximum">Specifies the maximum amount of time the algorithm is permitted to /// spend in a single time loop. This value can be overriden if certain actions are taken by the /// algorithm, such as invoking the training methods.</param> public AlgorithmTimeLimitManager(ITokenBucket additionalTimeBucket, TimeSpan timeLoopMaximum) { _timeLoopMaximum = timeLoopMaximum; AdditionalTimeBucket = additionalTimeBucket; }
public void SetUp() { _refillStrategy = new MockRefillStrategy(); _sleepStrategy = new Mock <ISleepStrategy>(); _bucket = new TokenBucket(Capacity, _refillStrategy, _sleepStrategy.Object); }
/// <summary> /// Provides an overload of <see cref="ITokenBucket.Consume"/> that accepts a <see cref="TimeSpan"/> timeout /// </summary> public static void Consume(this ITokenBucket bucket, long tokens, TimeSpan timeout) { bucket.Consume(tokens, (long)timeout.TotalMilliseconds); }
public ArtisanEndpoint(ITokenBucket tokenBucket) : base(tokenBucket) { }
private unsafe void LimitLoop(CancellationToken token) { while (!token.IsCancellationRequested) { var buffer = new WinDivertBuffer(); var address = new WinDivertAddress(); uint readLength = 0; bool recvResult = WinDivert.WinDivertRecv(_networkInfo.WinDivertHandle, buffer, ref address, ref readLength); if (!recvResult) { throw new Exception("WinDivert failed to receive packet"); } var parseResult = WinDivert.WinDivertHelperParsePacket(buffer, readLength); Host host = null; ITokenBucket bucket = null; WinDivertDirection?direction = null; if (parseResult.IPv4Header != (IPv4Header *)0) { lock (_ipHostDictLock) lock (_hostBucketDictLock) { if (_ipHostDict.TryGetValue(parseResult.IPv4Header->SrcAddr, out host)) { bucket = _hostBucketDict[host].Item1; direction = WinDivertDirection.Outbound; } else if (_ipHostDict.TryGetValue(parseResult.IPv4Header->DstAddr, out host)) { bucket = _hostBucketDict[host].Item2; direction = WinDivertDirection.Inbound; } } if (host != null && (host.LimitRule.IsBlocked || (direction == WinDivertDirection.Outbound && host.LimitRule.IsUploadBlocked) || (direction == WinDivertDirection.Inbound && host.LimitRule.IsDownloadBlocked))) { buffer.Dispose(); continue; } if (bucket != null) { bool passed = false; try { passed = bucket.TryConsume(readLength * 8); } catch (ArgumentOutOfRangeException) { } if (passed) { switch (direction) { case WinDivertDirection.Outbound: lock (_bandwidthUploadDictLock) _bandwidthUploadDict[host] += readLength * 8; break; case WinDivertDirection.Inbound: lock (_bandwidthDownloadDictLock) _bandwidthDownloadDict[host] += readLength * 8; break; } } else { buffer.Dispose(); continue; } } } WinDivert.WinDivertSend(_networkInfo.WinDivertHandle, buffer, readLength, ref address); buffer.Dispose(); } }