public GitHubRateLimiter(IGlobalConfigurationProvider globalConfigurationProvider)
{
limiter = TimeLimiter.GetFromMaxCountByInterval(
globalConfigurationProvider.GetMaxRequestsPerPeriod(),
TimeSpan.FromSeconds(globalConfigurationProvider.GetPeriodDurationInSeconds())
);
}
public async Task UsageWithFactory()
{
var wrapped = new TimeLimited(_Output);
var timeConstraint = TimeLimiter.GetFromMaxCountByInterval(5, TimeSpan.FromMilliseconds(100));
var timeLimited = timeConstraint.Proxify <ITimeLimited>(wrapped);
var watch = Stopwatch.StartNew();
for (var i = 0; i < 50; i++)
{
await timeLimited.GetValue();
}
watch.Stop();
watch.Elapsed.Should().BeGreaterThan(TimeSpan.FromMilliseconds(900));
_Output.WriteLine($"Elapsed: {watch.Elapsed}");
var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(110));
Func <Task> cancellable = async() =>
{
while (true)
{
await timeLimited.GetValue(cts.Token);
}
};
await cancellable.Should().ThrowAsync <OperationCanceledException>();
var res = await timeLimited.GetValue();
res.Should().Be(56);
}
/// <summary>
/// Register all the services that are specific to an external eve xml api web service
/// </summary>
/// <param name="builder"></param>
private void registerEVEAPIServices(ContainerBuilder builder)
{
builder.Register <EveXmlWebClient>(c => new EveXmlWebClient(
c.ResolveKeyed <IHttpClientWrapper>(WebServices.EVEXMLAPI),
c.Resolve <IConfigurationProvider>()))
.As <IEveXmlWebClient>()
.InstancePerLifetimeScope();
builder.Register <HttpClient>(c => HttpClientFactory.Create(
new HttpClientHandler(),
new RateLimitHandler(c.ResolveKeyed <IRateLimiter>(WebServices.EVEXMLAPI)),
new LoggingHandler(c.Resolve <ILogger>())))
.Keyed <HttpClient>(WebServices.EVEXMLAPI);
builder.Register(c =>
new HttpClientWrapper(
c.ResolveKeyed <HttpClient>(WebServices.EVEXMLAPI),
c.Resolve <MediaTypeFormatterCollection>()
)).Keyed <IHttpClientWrapper>(WebServices.EVEXMLAPI)
.SingleInstance();
builder.Register <TimeLimiter>(c => TimeLimiter.GetFromMaxCountByInterval(c.Resolve <IConfigurationProvider>().EveAPIRateLimit, TimeSpan.FromSeconds(1)))
.Keyed <IRateLimiter>(WebServices.EVEXMLAPI)
.SingleInstance();
}
public CryptoService(IDataCache cache, IHttpClientFactory httpFactory)
{
_log = LogManager.GetCurrentClassLogger();
_cache = cache;
_httpFactory = httpFactory;
ratelimit = TimeLimiter.GetFromMaxCountByInterval(1, TimeSpan.FromSeconds(2));
}
public IgdbApi(UpdatableAppSettings settings)
{
this.settings = settings;
requestLimiterHandler = TimeLimiter
.GetFromMaxCountByInterval(4, TimeSpan.FromSeconds(1))
.AsDelegatingHandler();
HttpClient = new HttpClient(requestLimiterHandler);
HttpClient.DefaultRequestHeaders.Add("Accept", "application/json");
CacheRoot = settings.Settings.IGDB.CacheDirectory;
if (!Path.IsPathRooted(CacheRoot))
{
CacheRoot = Path.Combine(Paths.ExecutingDirectory, CacheRoot);
}
Games = new Games(this);
AlternativeNames = new AlternativeNames(this);
InvolvedCompanies = new InvolvedCompanies(this);
Genres = new Genres(this);
Websites = new Websites(this);
GameModes = new GameModes(this);
PlayerPerspectives = new PlayerPerspectives(this);
Covers = new Covers(this);
Artworks = new Artworks(this);
Screenshots = new Screenshots(this);
AgeRatings = new AgeRatings(this);
Collections = new Collections(this);
}
public async Task <WorkloadResult> Execute(IBucket bucket, int workloadIndex)
{
Ensure.That(bucket, "bucket").IsNotNull();
await OnPreExecute(bucket, workloadIndex, 0);
var workloadResult = CreateWorkloadResult();
var workloadTimer = Stopwatch.StartNew();
if (_rateLimit == 0)
{
for (var i = 0; i < WorkloadSize; i++)
{
await CreateWorkloadTask(bucket, workloadIndex, 0, workloadResult);
}
}
else
{
var timeConstraint = TimeLimiter.GetFromMaxCountByInterval(_rateLimit, TimeSpan.FromSeconds(1));
for (var i = 0; i < WorkloadSize; i++)
{
await timeConstraint;
await CreateWorkloadTask(bucket, workloadIndex, 0, workloadResult);
}
}
workloadResult.TimeTaken = workloadTimer.Elapsed;
await OnPostExecute(bucket);
return(workloadResult);
}
public NexusModsIssueMonitor(ILogger <NexusModsIssueMonitor> logger, IClock clock, IServiceScopeFactory scopeFactory, IApplicationEnder applicationEnder) : base(applicationEnder)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_clock = clock ?? throw new ArgumentNullException(nameof(clock));
_scopeFactory = scopeFactory ?? throw new ArgumentNullException(nameof(scopeFactory));
_timeLimiter = TimeLimiter.GetFromMaxCountByInterval(1, TimeSpan.FromSeconds(90));
}
static ViewModelLocator()
{
ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
SimpleIoc.Default.Register <IRateLimiter>(() => TimeLimiter.GetFromMaxCountByInterval(2, TimeSpan.FromSeconds(1)));
SimpleIoc.Default.Register <ITwitchAPI>(() => new TwitchAPI(null, null, null));
SimpleIoc.Default.Register <MainViewModel>();
SimpleIoc.Default.Register <ApiExamplesViewModel>();
}
//private List<Task> tasks;
public SendMessage(ITelegramBotClient botClient)
{
//queue = new ConcurrentQueue<SendModel>();
GroupLimit = TimeLimiter.GetFromMaxCountByInterval(20, TimeSpan.FromMinutes(1));
GlobalLimit = TimeLimiter.GetFromMaxCountByInterval(30, TimeSpan.FromSeconds(1));
tasks = new ConcurrentQueue <Task>();
this.botClient = botClient;
}
public FaceIdentifierBase(string apiKey, string apiEndpoint)
{
Client = new FaceClient(new ApiKeyServiceClientCredentials(apiKey))
{
Endpoint = apiEndpoint
};
RateLimit = TimeLimiter.GetFromMaxCountByInterval(RateLimitRequests, RateLimitInterval);
}
public JsApi(HttpMessageHandler httpClientHandler, HistorySettings historySettings)
{
_historySettings = historySettings;
_httpClient = new HttpClient(httpClientHandler)
{
Timeout = TimeSpan.FromSeconds(4)
};
_rateLimiter = TimeLimiter.GetFromMaxCountByInterval(3, TimeSpan.FromSeconds(1.00f));
}
public async Task SimpleUsage()
{
var timeConstraint = TimeLimiter.GetFromMaxCountByInterval(5, TimeSpan.FromSeconds(1));
for (int i = 0; i < 1000; i++)
{
await timeConstraint.Enqueue(() => ConsoleIt());
}
}
public JsonServerHistoryPublisher(Settings settings, HttpMessageHandler httpMessageHandler)
{
_settings = settings;
_rateLimiter = TimeLimiter.GetFromMaxCountByInterval(5, TimeSpan.FromSeconds(1));
_httpClient = new HttpClient(httpMessageHandler)
{
Timeout = TimeSpan.FromSeconds(4)
};
}
protected override HttpMessageHandler CreateHandler(CreateHttpClientArgs args)
{
var handler = TimeLimiter
.GetFromMaxCountByInterval(1000, TimeSpan.FromSeconds(100))
.AsDelegatingHandler();
handler.InnerHandler = base.CreateHandler(args);
return(handler);
}
public async Task SimpleUsageAwaitable()
{
var timeConstraint = TimeLimiter.GetFromMaxCountByInterval(5, TimeSpan.FromSeconds(1));
for (var i = 0; i < 50; i++)
{
await timeConstraint;
ConsoleIt();
}
}
public Twitch(IConfigurationRoot config)
{
// Build handler with RateLimit
DelegatingHandler handler = TimeLimiter.GetFromMaxCountByInterval(750, TimeSpan.FromMinutes(1)).AsDelegatingHandler();
twitch = new HttpClient(handler);
// Set headers for the twitch api request
twitch.DefaultRequestHeaders.Add("Client-ID", config.GetApiKey("Twitch"));
twitch.DefaultRequestHeaders.Add("Authorization", config.GetApiKey("Twitch_OAuth"));
configuration = config;
}
public OpenWeatherMapClient(string apiKey)
{
_ApiKey = apiKey;
var handler = TimeLimiter
.GetFromMaxCountByInterval(60, TimeSpan.FromMinutes(1))
.AsDelegatingHandler();
_Client = new HttpClient(handler)
{
BaseAddress = new Uri("https://api.openweathermap.org/data/2.5/")
};
}
public VkApi(AccessToken token, HttpMessageHandler httpClientHandler)
{
_token = token;
_httpClient = new HttpClient(httpClientHandler)
{
Timeout = TimeSpan.FromSeconds(4)
};
_responseCache = new ConcurrentDictionary <string, VkApiResponseInfo>();
_requestLog = new ConcurrentDictionary <string, DateTimeOffset>();
_rateLimiter = TimeLimiter.GetFromMaxCountByInterval(3, TimeSpan.FromSeconds(1.00f));
}
/// <summary>Initializes a new instance of the <see cref="CoinMarketCapClient"/> class.</summary>
/// <param name="httpClient">The HTTP client.</param>
/// <param name="requestsPerMinute">The requests per minute.</param>
/// <exception cref="System.ArgumentNullException">httpClient</exception>
public CoinMarketCapClient(IRestClient httpClient, int requestsPerMinute)
{
this.gate = TimeLimiter.GetFromMaxCountByInterval(requestsPerMinute, new TimeSpan(0, 1, 0));
this.httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
var serializer = new CoinMarketCapSerializer();
this.HttpClient.UserAgent = "Inixe CoinManager";
this.HttpClient.AddHandler("application/json", serializer);
this.crytocurrencies = new Lazy <IList <string> >(this.LoadCrytoCurrencies);
}
public PipeDriveClient(string apiToken, int apiRate = DefaultApiRate)
{
_Client = new RestClient("https://api.pipedrive.com/v1");
_Client.AddHandler("application/json", PipeDriveJsonSerializer.Default);
_Client.AddHandler("text/json", PipeDriveJsonSerializer.Default);
_Client.AddHandler("text/x-json", PipeDriveJsonSerializer.Default);
_Client.AddHandler("text/javascript", PipeDriveJsonSerializer.Default);
_Client.AddHandler("*+json", PipeDriveJsonSerializer.Default);
_ApiToken = apiToken;
// Fly under the radar by doing only 99 requests per 10 seconds
_TimeContraint = TimeLimiter.GetFromMaxCountByInterval(apiRate, TimeSpan.FromSeconds(10));
}
/// <summary>Initializes a new instance of the <see cref="BitsoClientBase"/> class.</summary>
/// <param name="restClient">The rest client to use. This is often usefull for unit testing, If <c>null</c> a default RestClient will be used</param>
/// <param name="serverUrl">The server URL.</param>
/// <param name="apiKey">The Api key value</param>
/// <param name="apiSecret">The Api secret value</param>
/// <exception cref="ArgumentException">Invalid URL - serverUrl</exception>
/// <remarks>None</remarks>
protected BitsoClientBase(IRestClient restClient, string serverUrl, string apiKey, SecureString apiSecret)
{
if (!System.Uri.IsWellFormedUriString(serverUrl, System.UriKind.Absolute))
{
throw new ArgumentException("Invalid URL", nameof(serverUrl));
}
this.secureApiSecret = apiSecret;
this.apiKey = apiKey;
this.targetUrl = new Uri(serverUrl);
this.client = restClient ?? new RestClient(serverUrl);
this.disposedValue = false;
this.rateLimiter = TimeLimiter.GetFromMaxCountByInterval(300, new TimeSpan(0, 5, 0));
}
static void Main(string[] args)
{
Log("Starting tasks ...");
var constraint = TimeLimiter.GetFromMaxCountByInterval(1, TimeSpan.FromSeconds(0.5));
var tasks = new[]
{
DoWorkAsync("Task1", constraint),
DoWorkAsync("Task2", constraint),
DoWorkAsync("Task3", constraint),
DoWorkAsync("Task4", constraint)
};
Task.WaitAll(tasks);
Log("All tasks finished.");
Console.ReadLine();
}
public async Task SimpleUsageWithcancellation()
{
var timeconstraint = TimeLimiter.GetFromMaxCountByInterval(5, TimeSpan.FromSeconds(1));
var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(10));
for (int i = 0; i < 1000; i++)
{
try {
await timeconstraint.Perform(() => ConsoleIt(), cts.Token);
}
catch (Exception) {
}
}
}
public async Task SimpleUsageWithCancellation()
{
var timeConstraint = TimeLimiter.GetFromMaxCountByInterval(3, TimeSpan.FromSeconds(1));
var cts = new CancellationTokenSource(1100);
for (var i = 0; i < 1000; i++)
{
try
{
await timeConstraint.Enqueue(() => ConsoleIt(), cts.Token);
}
catch (Exception)
{
// ignored
}
}
}
public async Task ParallelSlowActionPerformance()
{
var stopWatch = Stopwatch.StartNew();
var limiter = TimeLimiter.GetFromMaxCountByInterval(100, TimeSpan.FromMinutes(1));
Func <Task> func = async() => await Task.Delay(300);
await Task.WhenAll(
limiter.Enqueue(func),
limiter.Enqueue(func),
limiter.Enqueue(func),
limiter.Enqueue(func),
limiter.Enqueue(func),
limiter.Enqueue(func));
stopWatch.Stop();
stopWatch.Elapsed.TotalSeconds.Should().BeLessThan(1);
}
public static async Task <IEnumerable <Models.Objects.Issue> > ListIssuesAsync(this GitHubClient s_gitHub, RepositoryInfo repo, SearchIssuesRequest issueQuery)
{
TimeLimiter rateLimiter = TimeLimiter.GetFromMaxCountByInterval(1, TimeSpan.FromSeconds(1));
List <Models.Objects.Issue> issuesFound = new List <Models.Objects.Issue>();
int totalPages = -1, currentPage = 0;
issueQuery.Repos.Add(repo.Owner, repo.Name);
do
{
currentPage++;
issueQuery.Page = currentPage;
SearchIssuesResult searchresults = null;
// make sure the rate limit is met
await rateLimiter;
searchresults = await s_gitHub.Search.SearchIssues(issueQuery);
Colorizer.WriteLine("Found [Yellow!{0}] issues in [Magenta!{1}].", searchresults.TotalCount, $"{repo.Owner}\\{repo.Name}");
foreach (Issue item in searchresults.Items)
{
Models.Objects.Issue issueFound = new Models.Objects.Issue(item)
{
// set the repo on the item
RepositoryName = repo.Name,
OrganizationName = repo.Owner
};
issuesFound.Add(issueFound);
}
// if this is the first call, setup the totalpages stuff
if (totalPages == -1)
{
totalPages = (searchresults.TotalCount / 100) + 1;
}
Colorizer.WriteLine("Retrieved [Yellow!{0}]/[Yellow!{1}] issues.", issuesFound.Count, searchresults.TotalCount);
} while (totalPages > currentPage);
return(issuesFound);
}
/// <summary>
/// Creates an Instance of the TwitchAPI Class.
/// </summary>
/// <param name="clientId">Twitch Client Id.</param>
/// <param name="accessToken">Twitch Access Token.</param>
/// <param name="rateLimit">Should RateLimit Requests?</param>
/// <param name="rateLimiter">Instance Of RateLimiter. Useful if using multiple API instances on one connection and you wish to share the requests ratelimiter.</param>
/// <param name="callsPerPeriod">Number of Requests per Period to rate limit to</param>
/// <param name="ratePeriod">Period for Rate Limit (In Seconds)</param>
public TwitchAPI(string clientId = null, string accessToken = null, bool rateLimit = true, IRateLimiter rateLimiter = null, int callsPerPeriod = 1, int ratePeriod = 1)
{
_rateLimiter = rateLimit ?
(rateLimiter ?? TimeLimiter.GetFromMaxCountByInterval(callsPerPeriod, TimeSpan.FromSeconds(ratePeriod)))
: BypassLimiter.CreateLimiterBypassInstance();
Auth = new Auth(this);
Blocks = new Blocks(this);
Badges = new Badges(this);
Bits = new Bits(this);
ChannelFeeds = new ChannelFeeds(this);
Channels = new Channels(this);
Chat = new Chat(this);
Clips = new Clips(this);
Collections = new Collections(this);
Communities = new Communities(this);
Follows = new Follows(this);
Games = new Games(this);
Ingests = new Ingests(this);
Root = new Root(this);
Search = new Search(this);
Streams = new Streams(this);
Subscriptions = new Subscriptions(this);
Teams = new Teams(this);
ThirdParty = new ThirdParty(this);
Undocumented = new Undocumented(this);
Users = new Users(this);
Videos = new Videos(this);
Webhooks = new Webhooks(this);
Debugging = new Debugging();
Settings = new ApiSettings(this);
_jsonSerializer = new TwitchLibJsonSerializer();
if (!string.IsNullOrWhiteSpace(clientId))
{
Settings.ClientId = clientId;
}
if (!string.IsNullOrWhiteSpace(accessToken))
{
Settings.AccessToken = accessToken;
}
}
private void SetThrottler()
{
if (this.targetThroughput > 0)
{
// 25% extra for overhead - maybe, need a more scientific way to calc, 0% for now
double overheadCompensator = this.dryRun ? 1.0 : 1.0;
double controlInterval = 1.0; // seconds
// how many invokations per second are allowed
double invocationsPerControlInterval = (double)(this.targetThroughput * overheadCompensator) / (double)this.batchSize * controlInterval;
double clampBelowInterval = controlInterval / invocationsPerControlInterval * 1000.0;
// renormalise to avoid fractional invocations
if (invocationsPerControlInterval < 100)
{
double normaliser = 100.0 / invocationsPerControlInterval;
invocationsPerControlInterval = normaliser * invocationsPerControlInterval;
controlInterval = normaliser * controlInterval;
}
// does not make sence to clamp from below at < 15ms - timers aren't that precise
if (clampBelowInterval < 15.0)
{
this.throttler = TimeLimiter.GetFromMaxCountByInterval(Convert.ToInt32(invocationsPerControlInterval), TimeSpan.FromSeconds(controlInterval));
}
else
{
var clampAbove = new CountByIntervalAwaitableConstraint(Convert.ToInt32(invocationsPerControlInterval), TimeSpan.FromSeconds(controlInterval));
// Clamp from below: e.g. one invocation every 100 ms
var clampBelow = new CountByIntervalAwaitableConstraint(1, TimeSpan.FromMilliseconds(clampBelowInterval));
//Compose the two constraints
this.throttler = TimeLimiter.Compose(clampAbove, clampBelow);
}
}
else // no throttling
{
this.throttler = TimeLimiter.GetFromMaxCountByInterval(Int32.MaxValue, TimeSpan.FromSeconds(1));
}
}
public async Task SimpleUsageAwaitableCancellable()
{
var timeConstraint = TimeLimiter.GetFromMaxCountByInterval(5, TimeSpan.FromSeconds(1));
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1.1));
var token = cts.Token;
var count = 0;
Func <Task> cancellable = async() =>
{
while (true)
{
await timeConstraint;
token.ThrowIfCancellationRequested();
ConsoleIt();
count++;
}
};
await cancellable.Should().ThrowAsync <OperationCanceledException>();
count.Should().Be(10);
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices((hostContext, services) =>
{
// Load up the image content we will use for the tests
ByteArrayContent content;
using (var fs = File.OpenRead(@".\Documents\Page11_Image1.jpg"))
{
byte[] byteData;
fs.Position = 0;
using (var binaryReader = new BinaryReader(fs))
{
byteData = binaryReader.ReadBytes((int)fs.Length);
}
content = new ByteArrayContent(byteData);
content.Headers.ContentType =
new MediaTypeHeaderValue("application/octet-stream");
}
// Set up a shared Time based RateLimiter (for all calls to service)
var callsPerSecond = 5;
Console.WriteLine($"TimeLimiter Max Calls/Sec: {callsPerSecond}");
var timeLimiter = TimeLimiter.GetFromMaxCountByInterval(callsPerSecond, TimeSpan.FromSeconds(1));
// Add 'n' Workers
var maxDOP = 20;
for (int i = 0; i < maxDOP; i++)
{
int workerId = i;
services.AddSingleton <IHostedService>(
sp => new TestWorker(
serviceProvider: sp,
workerId: workerId,
timeLimiter: timeLimiter,
imageContent: content
)
);
}
});