public static void EnqueueReceiveMessage(IConnection connection, IEncryption decryptor, IRateLimiter rateLimiter, ConnectionMonitor monitor, TorrentManager manager, AsyncMessageReceivedCallback callback, object state) { // FIXME: Hardcoded number int count = 4; var buffer = ClientEngine.BufferManager.GetBuffer (count); var data = receiveCache.Dequeue ().Initialise (connection, decryptor, rateLimiter, monitor, manager, buffer, callback, state); NetworkIO.EnqueueReceive (connection, buffer, 0, count, rateLimiter, monitor, data.ManagerMonitor, MessageLengthReceivedCallback, data); }
public QueuedIO(IConnection connection, byte [] buffer, int offset, int count, IRateLimiter rateLimiter, TaskCompletionSource <int> tcs) { this.connection = connection; this.buffer = buffer; this.offset = offset; this.count = count; this.rateLimiter = rateLimiter; this.tcs = tcs; }
public ThrottlingFilter( IRateLimiter rateLimiter, IThrottleService throttleService, IOptionsSnapshot <ThrottleOptions> throttleOptions) { _throttleOptions = throttleOptions.Value; _rateLimiter = rateLimiter; _throttleService = throttleService; }
public void Add(IRateLimiter limiter) { if (rateLimiters == null) { rateLimiters = new List <IRateLimiter>(); } rateLimiters.Add(limiter); }
/// <summary> /// Creates a new <see cref="RiotClient"/> instance. /// </summary> /// <param name="settings">The settings to use.</param> /// <param name="platformId">The platform ID of the default server to connect to. This should equal one of the <see cref="Models.PlatformId"/> values.</param> /// <param name="appRateLimiter">The rate limiter to use for proactive rate limiting.</param> /// <remarks> /// You should pass the same <see cref="IRateLimiter"/> instance to all <see cref="RiotClient"/> instances. Do not create multiple <see cref="IRateLimiter"/> instances. /// Reactive rate limiting will always be used, even if a proactive rate limiter is not specified. /// </remarks> public RiotClient(RiotClientSettings settings, string platformId, IRateLimiter appRateLimiter) { this.settings = settings; this.platformId = platformId; this.rateLimiter = appRateLimiter; client = CreateHttpClient(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); }
public RpcService(RpcActor localActor, IRateLimiter rateLimiter) : this(localActor) { if (rateLimiter == null) { throw new ArgumentNullException("rateLimiter"); } _rateLimiter = rateLimiter; }
public void Remove(IRateLimiter limiter) { if (rateLimiters.Contains(limiter) == false) { throw new KeyNotFoundException(); } rateLimiters.Remove(limiter); }
public WumpusRequester(HttpClient httpClient, JsonSerializer serializer, IRateLimiter rateLimiter) : base(httpClient) { _serializer = serializer; _rateLimiter = rateLimiter; ResponseDeserializer = new WumpusResponseDeserializer(_serializer); RequestBodySerializer = new WumpusBodySerializer(_serializer); RequestQueryParamSerializer = new WumpusQueryParamSerializer(_serializer); }
public static void EnqueueSend(IConnection connection, byte[] buffer, int offset, int count, IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor, AsyncIOCallback callback, object state) { var data = TransferCache.Dequeue() .Initialise(connection, buffer, offset, count, callback, state, rateLimiter, peerMonitor, managerMonitor); lock (SendQueue) SendOrEnqueue(data); }
public WebAgent(IRateLimiter rateLimiter, IProxyService proxyService) { _rateLimiter = rateLimiter; _proxyService = proxyService; _acceptedEncoding = new Dictionary <string, Func <Stream, Stream> > { { "gzip", (stream) => new GZipStream(stream, CompressionMode.Decompress) }, { "deflate", (stream) => new DeflateStream(stream, CompressionMode.Decompress) } }; }
public XeroHttpClient(string baseUri, IAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper jsonMapper, IXmlObjectMapper xmlMapper, IRateLimiter rateLimiter = null) { this.baseUri = new Uri(baseUri); this.auth = auth; this.consumer = consumer; this.user = user; this.rateLimiter = rateLimiter; this.jsonMapper = jsonMapper; this.xmlMapper = xmlMapper; }
public static void EnqueueSendMessage (IConnection connection, IEncryption encryptor, PeerMessage message, IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor, AsyncIOCallback callback, object state) { int count = message.ByteLength; var buffer = ClientEngine.BufferManager.GetBuffer (count); message.Encode (buffer, 0); encryptor.Encrypt (buffer, 0, count); var data = sendCache.Dequeue ().Initialise (buffer, callback, state); NetworkIO.EnqueueSend (connection, buffer, 0, count, rateLimiter, peerMonitor, managerMonitor, EndSendCallback, data); }
public BinanceDexApi(IHttp http, string baseUrl, string hrp, IRateLimiter rateLimiter) { Throw.IfNull(http, nameof(http)); Throw.IfNullOrWhiteSpace(baseUrl, nameof(baseUrl)); this.http = http; this.baseUrl = baseUrl; this.Hrp = hrp; this.rateLimiterImplementation = rateLimiter; }
public FetchJustTimeEntriesSinceState( ITogglApi api, ISinceParameterRepository since, ITimeService timeService, ILeakyBucket leakyBucket, IRateLimiter limiter) : base(api, leakyBucket, since, timeService) { this.limiter = limiter; }
public RateLimitingSampler(double maxTracesPerSecond, IRateLimiter rateLimiter) { MaxTracesPerSecond = maxTracesPerSecond; _rateLimiter = rateLimiter ?? throw new ArgumentNullException(nameof(rateLimiter)); _tags = new Dictionary <string, object> { { SamplerConstants.SamplerTypeTagKey, SamplerConstants.SamplerTypeRateLimiting }, { SamplerConstants.SamplerParamTagKey, maxTracesPerSecond } }; }
public TheStartMethod() { sinceParameters = Substitute.For <ISinceParameterRepository>(); api = Substitute.For <ITogglApi>(); timeService = Substitute.For <ITimeService>(); leakyBucket = Substitute.For <ILeakyBucket>(); leakyBucket.TryClaimFreeSlots(Arg.Any <int>(), out _).Returns(true); rateLimiter = Substitute.For <IRateLimiter>(); rateLimiter.WaitForFreeSlot().Returns(Observable.Return(Unit.Default)); timeService.CurrentDateTime.Returns(now); state = new FetchAllSinceState(api, sinceParameters, timeService, leakyBucket, rateLimiter); }
/// <summary> /// Adds a rate limiter to the client. There are 2 choices, the <see cref="RateLimiterTotal"/> and the <see cref="RateLimiterPerEndpoint"/>. /// </summary> /// <param name="limiter">The limiter to add</param> public void AddRateLimiter(IRateLimiter limiter) { if (limiter == null) { throw new ArgumentNullException(nameof(limiter)); } var rateLimiters = RateLimiters.ToList(); rateLimiters.Add(limiter); RateLimiters = rateLimiters; }
/// <summary> /// Constructor /// </summary> /// <param name="ethereumNetworkRegistry">Ethereum network registry</param> /// <param name="groupNameGenerator">The group name generator</param> /// <param name="environment">Execution environment</param> /// <param name="subscriptionManager">Subscription manager</param> /// <param name="playerCountManager">Player counter.</param> /// <param name="rateLimiter">Rate limiter</param> /// <param name="logger">Logger</param> public AuthenticatedHub(IEthereumNetworkRegistry ethereumNetworkRegistry, IGroupNameGenerator groupNameGenerator, ExecutionEnvironment environment, ISubscriptionManager subscriptionManager, IPlayerCountManager playerCountManager, IRateLimiter rateLimiter, ILogger <AuthenticatedHub> logger) : base(ethereumNetworkRegistry: ethereumNetworkRegistry, groupNameGenerator: groupNameGenerator, environment: environment, subscriptionManager: subscriptionManager, logger: logger) { this._playerCountManager = playerCountManager ?? throw new ArgumentNullException(nameof(playerCountManager)); this._rateLimiter = rateLimiter ?? throw new ArgumentNullException(nameof(rateLimiter)); }
public ComputerController(IAuthorizationService authorizationService, ILogger <ComputerController> logger, IDirectory directory, IAuditEventProcessor reporting, IRateLimiter rateLimiter, IOptionsSnapshot <UserInterfaceOptions> userInterfaceSettings, IAuthenticationProvider authenticationProvider, IPasswordProvider passwordProvider, IJitAccessProvider jitAccessProvider) { this.authorizationService = authorizationService; this.logger = logger; this.directory = directory; this.reporting = reporting; this.rateLimiter = rateLimiter; this.userInterfaceSettings = userInterfaceSettings.Value; this.authenticationProvider = authenticationProvider; this.passwordProvider = passwordProvider; this.jitAccessProvider = jitAccessProvider; }
/// <summary> /// Creates an Instance of the TwitchAPI Class. /// </summary> /// <param name="loggerFactory">Instance Of LoggerFactory, otherwise no logging is used, </param> /// <param name="rateLimiter">Instance Of RateLimiter, otherwise no ratelimiter is used.</param> /// <param name="settings">Instance of ApiSettings, otherwise defaults used, can be changed later</param> /// <param name="http">Instance of HttpCallHandler, otherwise default handler used</param> public TwitchAPI(ILoggerFactory loggerFactory = null, IRateLimiter rateLimiter = null, IApiSettings settings = null, IHttpCallHandler http = null) { _logger = loggerFactory?.CreateLogger <TwitchAPI>(); var _rateLimiter = rateLimiter ?? BypassLimiter.CreateLimiterBypassInstance(); var _http = http ?? new TwitchHttpClient(loggerFactory?.CreateLogger <TwitchHttpClient>()); Settings = settings ?? new ApiSettings(); Helix = new Helix.Helix(loggerFactory, rateLimiter, Settings, _http); V5 = new V5.V5(loggerFactory, _rateLimiter, Settings, _http); ThirdParty = new ThirdParty.ThirdParty(Settings, _rateLimiter, _http); Undocumented = new Undocumented(Settings, _rateLimiter, _http); }
public FetchAllSinceState( ITogglApi api, ISinceParameterRepository since, ITimeService timeService, ILeakyBucket leakyBucket, IRateLimiter limiter) { this.api = api; this.since = since; this.timeService = timeService; this.leakyBucket = leakyBucket; this.limiter = limiter; }
public ReceiveMessageState Initialise(IConnection connection, IEncryption decryptor, IRateLimiter limiter, ConnectionMonitor peerMonitor, TorrentManager manager, byte[] buffer, AsyncMessageReceivedCallback callback, object state) { Connection = connection; Decryptor = decryptor; Manager = manager; Buffer = buffer; PeerMonitor = peerMonitor; RateLimiter = limiter; ManagerMonitor = manager == null ? null : manager.Monitor; Callback = callback; State = state; return(this); }
public ReceiveMessageState Initialise (IConnection connection, IEncryption decryptor, IRateLimiter limiter, ConnectionMonitor peerMonitor, TorrentManager manager, byte[] buffer, AsyncMessageReceivedCallback callback, object state) { Connection = connection; Decryptor = decryptor; Manager = manager; Buffer = buffer; PeerMonitor = peerMonitor; RateLimiter = limiter; ManagerMonitor = manager == null ? null : manager.Monitor; Callback = callback; State = state; return this; }
/// <summary> /// Creates an Instance of the TwitchAPI Class. /// </summary> /// <param name="loggerFactory">Instance Of LoggerFactory, otherwise no logging is used, </param> /// <param name="rateLimiter">Instance Of RateLimiter, otherwise no ratelimiter is used.</param> /// <param name="settings">Instance of ApiSettings, otherwise defaults used, can be changed later</param> /// <param name="http">Instance of HttpCallHandler, otherwise default handler used</param> public TwitchAPI(ILoggerFactory loggerFactory = null, IRateLimiter rateLimiter = null, IApiSettings settings = null, IHttpCallHandler http = null) { _logger = loggerFactory?.CreateLogger <TwitchAPI>(); rateLimiter = rateLimiter ?? BypassLimiter.CreateLimiterBypassInstance(); http = http ?? new TwitchHttpClient(loggerFactory?.CreateLogger <TwitchHttpClient>()); Settings = settings ?? new ApiSettings(); Auth = new Auth.Auth(Settings, rateLimiter, http); Helix = new Helix.Helix(loggerFactory, rateLimiter, Settings, http); ThirdParty = new ThirdParty.ThirdParty(Settings, rateLimiter, http); Undocumented = new Undocumented(Settings, rateLimiter, http); Settings.PropertyChanged += SettingsPropertyChanged; }
public static void ShouldNotPermitAnExecution(this IRateLimiter rateLimiter, TimeSpan?retryAfter = null) { (bool permitExecution, TimeSpan retryAfter)canExecute = rateLimiter.PermitExecution(); canExecute.permitExecution.Should().BeFalse(); if (retryAfter == null) { canExecute.retryAfter.Should().BeGreaterThan(TimeSpan.Zero); } else { canExecute.retryAfter.Should().Be(retryAfter.Value); } }
private readonly IRateLimiter _rateLimiter3; // CanExecute will always return false and tokens will not be updated on any iteration public Single_RateLimiter() { _rateLimiter1 = RateLimiter .WithRateLimit(new RateLimit(Int32.MaxValue, TimeSpan.FromMinutes(1))) .Build(); _rateLimiter2 = RateLimiter .WithRateLimit(new RateLimit(Int32.MaxValue, TimeSpan.MaxValue)) .Build(); _rateLimiter3 = RateLimiter .WithRateLimit(new RateLimit(0, TimeSpan.FromMinutes(1))) .Build(); }
private readonly IRateLimiter <int> _rateLimiter3; // CanExecute will always return false and tokens will not be updated on any iteration public Multi_RateLimiter() { _rateLimiter1 = RateLimiter .WithRateLimits(new[] { new KeyValuePair <int, RateLimit>(1, new RateLimit(Int32.MaxValue, TimeSpan.FromMinutes(1))) }) .Build(); _rateLimiter2 = RateLimiter .WithRateLimits(new[] { new KeyValuePair <int, RateLimit>(1, new RateLimit(Int32.MaxValue, TimeSpan.MaxValue)) }) .Build(); _rateLimiter3 = RateLimiter .WithRateLimits(new[] { new KeyValuePair <int, RateLimit>(1, new RateLimit(0, TimeSpan.FromMinutes(1))) }) .Build(); }
public RateLimitingFilter(IRateLimiter rateLimiter, HttpFilterCollection httpFilters, Func <RateLimitingRequest, RateLimitPolicy, RateLimitingResult, HttpActionContext, Task <Decision> > onPostLimit = null, Func <RateLimitingRequest, RateLimitPolicy, RateLimitingResult, HttpActionContext, Task> onPostLimitRevert = null, Func <RateLimitingRequest, RateLimitPolicy, RateLimitingResult, HttpActionExecutedContext, Task <Decision> > postOperationDecisionFuncAsync = null, Func <RateLimitingRequest, HttpActionContext, Task <RateLimitPolicy> > getPolicyFuncAsync = null, bool simulationMode = false) { _rateLimiter = rateLimiter; httpFilters.Add(new RateLimitingPostActionFilter(_filterId)); OnPostLimit = onPostLimit; OnPostLimitRevert = onPostLimitRevert; PostOperationDecisionFuncAsync = postOperationDecisionFuncAsync; GetPolicyFuncAsync = getPolicyFuncAsync; SimulationMode = simulationMode; }
public static void EnqueueSendMessage(IConnection connection, IEncryption encryptor, PeerMessage message, IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor, AsyncIOCallback callback, object state) { var count = message.ByteLength; var buffer = ClientEngine.BufferManager.GetBuffer(count); message.Encode(buffer, 0); encryptor.Encrypt(buffer, 0, count); var data = SendCache.Dequeue().Initialise(buffer, callback, state); NetworkIO.EnqueueSend(connection, buffer, 0, count, rateLimiter, peerMonitor, managerMonitor, EndSendCallback, data); }
public void RateLimit(Uri uri) { if (uri == null) throw new ArgumentNullException("uri"); IRateLimiter rateLimiter = GetRateLimter(uri, _defaultMinCrawlDelayInMillisecs); if (rateLimiter == null) return; Stopwatch timer = Stopwatch.StartNew(); rateLimiter.WaitToProceed(); timer.Stop(); if(timer.ElapsedMilliseconds > 10) _logger.DebugFormat("Rate limited [{0}] [{1}] milliseconds", uri.AbsoluteUri, timer.ElapsedMilliseconds); }
private static void configurePullTimeEntriesTransitions( ITransitionConfigurator transitions, ITogglApi api, ITogglDataSource dataSource, ITogglDatabase database, IAnalyticsService analyticsService, ITimeService timeService, ILeakyBucket leakyBucket, IRateLimiter rateLimiter, ILastTimeUsageStorage lastTimeUsageStorage, StateResult entryPoint) { var fetchTimeEntries = new FetchJustTimeEntriesSinceState(api, database.SinceParameters, timeService, leakyBucket, rateLimiter); var ensureFetchTimeEntriesSucceeded = new EnsureFetchListSucceededState <ITimeEntry>(); var placeholderStateFactory = new CreatePlaceholdersStateFactory( dataSource, analyticsService, lastTimeUsageStorage, timeService); var createWorkspacePlaceholder = placeholderStateFactory.ForWorkspaces(); var createProjectPlaceholder = placeholderStateFactory.ForProjects(); var createTaskPlaceholder = placeholderStateFactory.ForTasks(); var createTagPlaceholder = placeholderStateFactory.ForTags(); var persistTimeEntries = new PersistListState <ITimeEntry, IDatabaseTimeEntry, IThreadSafeTimeEntry>(dataSource.TimeEntries, TimeEntry.Clean); var updateTimeEntriesSinceDate = new UpdateSinceDateState <ITimeEntry>(database.SinceParameters); var timeEntriesAnalytics = new TimeEntriesAnalyticsState(analyticsService); transitions.ConfigureTransition(entryPoint, fetchTimeEntries); transitions.ConfigureTransition(fetchTimeEntries.PreventOverloadingServer, new DeadEndState()); transitions.ConfigureTransition(fetchTimeEntries.Done, ensureFetchTimeEntriesSucceeded); transitions.ConfigureTransition(ensureFetchTimeEntriesSucceeded.ErrorOccured, new FailureState()); transitions.ConfigureTransition(ensureFetchTimeEntriesSucceeded.Done, timeEntriesAnalytics); transitions.ConfigureTransition(timeEntriesAnalytics.Done, createWorkspacePlaceholder); transitions.ConfigureTransition(createWorkspacePlaceholder.Done, createProjectPlaceholder); transitions.ConfigureTransition(createProjectPlaceholder.Done, createTaskPlaceholder); transitions.ConfigureTransition(createTaskPlaceholder.Done, createTagPlaceholder); transitions.ConfigureTransition(createTagPlaceholder.Done, persistTimeEntries); transitions.ConfigureTransition(persistTimeEntries.Done, updateTimeEntriesSinceDate); transitions.ConfigureTransition(updateTimeEntriesSinceDate.Done, new DeadEndState()); }
/// <summary> /// Creates an Instance of the Helix Class. /// </summary> /// <param name="loggerFactory">Instance Of LoggerFactory, otherwise no logging is used, </param> /// <param name="rateLimiter">Instance Of RateLimiter, otherwise no ratelimiter is used.</param> /// <param name="settings">Instance of ApiSettings, otherwise defaults used, can be changed later</param> /// <param name="http">Instance of HttpCallHandler, otherwise default handler used</param> public Helix(ILoggerFactory loggerFactory = null, IRateLimiter rateLimiter = null, IApiSettings settings = null, IHttpCallHandler http = null) { _logger = loggerFactory?.CreateLogger <Helix>(); rateLimiter = rateLimiter ?? BypassLimiter.CreateLimiterBypassInstance(); http = http ?? new TwitchHttpClient(loggerFactory?.CreateLogger <TwitchHttpClient>()); Settings = settings ?? new ApiSettings(); Analytics = new Analytics(Settings, rateLimiter, http); Bits = new Bits(Settings, rateLimiter, http); Clips = new Clips(Settings, rateLimiter, http); Entitlements = new Entitlements(Settings, rateLimiter, http); Games = new Games(Settings, rateLimiter, http); Streams = new Streams(Settings, rateLimiter, http); Users = new Users(Settings, rateLimiter, http); Videos = new Videos(Settings, rateLimiter, http); Webhooks = new Webhooks(Settings, rateLimiter, http); }
public AsyncIOState Initialise(IConnection connection, byte[] buffer, int offset, int count, AsyncIOCallback callback, object state, IRateLimiter limiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor) { Connection = connection; Buffer = buffer; Count = count; Callback = callback; Offset = offset; ManagerMonitor = managerMonitor; PeerMonitor = peerMonitor; RateLimiter = limiter; Remaining = count; State = state; return this; }
public AsyncIOState Initialise(IConnection connection, byte[] buffer, int offset, int count, AsyncIOCallback callback, object state, IRateLimiter limiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor) { Connection = connection; Buffer = buffer; Count = count; Callback = callback; Offset = offset; ManagerMonitor = managerMonitor; PeerMonitor = peerMonitor; RateLimiter = limiter; Remaining = count; State = state; return(this); }
public ThrottlingIntegrationProxy(IIntegrationProxy innerIntegrationProxy, IRateLimiter rateLimiter) { _innerIntegrationProxy = innerIntegrationProxy; _rateLimiter = rateLimiter; }
protected XeroApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper, IRateLimiter rateLimiter) : this(baseUri) { Client = new XeroHttpClient(baseUri, auth, consumer, user, readMapper, writeMapper, rateLimiter); }
public HttpClient(string baseUri, IAuthenticator auth, IConsumer consumer, IUser user, IRateLimiter rateLimiter) : this(baseUri, auth, consumer, user) { _rateLimiter = rateLimiter; }
protected PayrollApi(string baseUri, IAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper, IRateLimiter rateLimiter) : base(baseUri, auth, consumer, user, readMapper, writeMapper, rateLimiter) { }
public void Add(IRateLimiter limiter) { Check.Limiter(limiter); limiters.Add(limiter); }
public void Remove(IRateLimiter limiter) { Check.Limiter(limiter); limiters.Remove(limiter); }
public XeroCoreApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user, IRateLimiter rateLimiter) : this(baseUri, auth, consumer, user, new DefaultMapper(), new DefaultMapper(), rateLimiter) { }
public XeroCoreApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper, IRateLimiter rateLimiter) : base(baseUri, auth, consumer, user, readMapper, writeMapper, rateLimiter) { Connect(); }
public AustralianPayroll(string baseUri, IAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper, IRateLimiter rateLimiter) : base(baseUri, auth, consumer, user, readMapper, writeMapper, rateLimiter) { Connect(); }
public static void EnqueueSend(IConnection connection, byte[] buffer, int offset, int count, IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor, AsyncIOCallback callback, object state) { var data = transferCache.Dequeue ().Initialise (connection, buffer, offset, count, callback, state, rateLimiter, peerMonitor, managerMonitor); lock (sendQueue) SendOrEnqueue (data); }
public GlobalRateLimiter(IRateLimiter limiter) { Check.Limiter(limiter); this.limiter = limiter; }