public async Task PrepareTwitterRequestAsync(ITwitterRequest request)
{
var twitterQuery = request.Query;
twitterQuery.Url = CleanupQueryUrl(twitterQuery.Url); // TODO : THIS LOGIC SHOULD HAPPEN BEFORE ARRIVING HERE
var rateLimitTrackerMode = request.ExecutionContext.RateLimitTrackerMode;
if (rateLimitTrackerMode == RateLimitTrackerMode.None)
{
return;
}
// Use the RateLimitCacheManager instead of RateLimitHelper to get the queryRateLimits to ensure the cache is up to date!
var credentialRateLimits = await _rateLimitCacheManager.GetCredentialsRateLimitsAsync(twitterQuery.TwitterCredentials).ConfigureAwait(false);
IEndpointRateLimit queryRateLimit = null;
// If we were not able to retrieve the credentials few ms before there is no reason why it would work now.
if (credentialRateLimits != null)
{
var getEndpointRateLimitsFromCache = new GetEndpointRateLimitsParameters(twitterQuery.Url, RateLimitsSource.CacheOnly);
queryRateLimit = await _rateLimitCacheManager.GetQueryRateLimitAsync(getEndpointRateLimitsFromCache, twitterQuery.TwitterCredentials).ConfigureAwait(false);
}
var timeToWait = _rateLimitAwaiter.GetTimeToWaitFromQueryRateLimit(queryRateLimit, request.ExecutionContext);
twitterQuery.CredentialsRateLimits = credentialRateLimits;
twitterQuery.QueryRateLimit = queryRateLimit;
twitterQuery.DateWhenCredentialsWillHaveTheRequiredRateLimits = DateTime.UtcNow.Add(timeToWait);
}
public async Task QueryExecutedAsync(string query, ITwitterCredentials credentials, Dictionary <string, IEnumerable <string> > rateLimitHeaders)
{
if (rateLimitHeaders != null && rateLimitHeaders.Count > 0)
{
var rateLimit = await _rateLimitCacheManager.GetQueryRateLimitAsync(new GetEndpointRateLimitsParameters(query), credentials).ConfigureAwait(false);
if (rateLimit == null)
{
rateLimit = new EndpointRateLimit();
var rateLimits = await _rateLimitCacheManager.GetCredentialsRateLimitsAsync(credentials).ConfigureAwait(false);
if (rateLimits == null)
{
// If the user runs out of RateLimit requests
return;
}
var endpointUrl = new Uri(query).GetEndpointURL();
rateLimits.OtherEndpointRateLimits[new TwitterEndpointAttribute(endpointUrl)] = rateLimit;
}
IEnumerable <string> limitHeaders;
if (rateLimitHeaders.TryGetValue("x-rate-limit-limit", out limitHeaders))
{
var limit = limitHeaders.FirstOrDefault();
if (limit != null)
{
rateLimit.Limit = int.Parse(limit);
}
}
IEnumerable <string> remainingHeaders;
if (rateLimitHeaders.TryGetValue("x-rate-limit-remaining", out remainingHeaders))
{
var remaining = remainingHeaders.FirstOrDefault();
if (remaining != null)
{
rateLimit.Remaining = int.Parse(remaining);
}
}
IEnumerable <string> resetHeaders;
if (rateLimitHeaders.TryGetValue("x-rate-limit-reset", out resetHeaders))
{
var reset = resetHeaders.FirstOrDefault();
if (reset != null)
{
rateLimit.Reset = int.Parse(reset);
}
}
}
else
{
await QueryExecutedAsync(query, credentials).ConfigureAwait(false);
}
}
public async Task <ICredentialsRateLimits> GetRateLimitsAsync(IGetRateLimitsParameters parameters)
{
switch (parameters.From)
{
case RateLimitsSource.CacheOnly:
return(await _rateLimitCacheManager.RateLimitCache.GetCredentialsRateLimitsAsync(_client.Credentials).ConfigureAwait(false));
case RateLimitsSource.TwitterApiOnly:
var twitterResult = await _helpRequester.GetRateLimitsAsync(parameters).ConfigureAwait(false);
return(_client.Factories.CreateRateLimits(twitterResult?.Model));
case RateLimitsSource.CacheOrTwitterApi:
return(await _rateLimitCacheManager.GetCredentialsRateLimitsAsync(_client.Credentials).ConfigureAwait(false));
default:
throw new ArgumentException(nameof(parameters.From));
}
}
