public WaitingForRateLimitEventArgs(
ITwitterRequest request,
IEndpointRateLimit queryRateLimit)
{
Request = request;
_queryRateLimit = queryRateLimit;
}
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 QueryAwaitingEventArgs(
string query,
IEndpointRateLimit queryRateLimit,
ITwitterCredentials twitterCredentials)
{
_query = query;
_queryRateLimit = queryRateLimit;
_twitterCredentials = twitterCredentials;
}
public QueryAwaitingEventArgs(
string query,
IEndpointRateLimit queryRateLimit,
IReadOnlyTwitterCredentials twitterCredentials)
{
_query = query;
_queryRateLimit = queryRateLimit;
_twitterCredentials = twitterCredentials;
}
private bool DoesQueryNeedsToRefreshTheCacheInformation(IEndpointRateLimit rateLimit)
{
if (rateLimit == null || rateLimit.IsCustomHeaderRateLimit)
{
return(false);
}
return(rateLimit.ResetDateTime < DateTime.Now);
}
public int GetTimeToWaitFromQueryRateLimit(IEndpointRateLimit queryRateLimit)
{
if (queryRateLimit == null)
{
return 0;
}
return queryRateLimit.Remaining == 0 ? ((int) queryRateLimit.ResetDateTimeInMilliseconds) : 0;
}
public WaitingForRateLimitEventArgs(
string url,
IEndpointRateLimit queryRateLimit,
IReadOnlyTwitterCredentials twitterCredentials)
{
_url = url;
_queryRateLimit = queryRateLimit;
_twitterCredentials = twitterCredentials;
}
public int GetTimeToWaitFromQueryRateLimit(IEndpointRateLimit queryRateLimit)
{
if (queryRateLimit == null)
{
return(0);
}
return(queryRateLimit.Remaining == 0 ? ((int)queryRateLimit.ResetDateTimeInMilliseconds) : 0);
}
public virtual bool ShouldEndpointCacheBeUpdated(IEndpointRateLimit rateLimit)
{
if (rateLimit == null || rateLimit.IsCustomHeaderRateLimit)
{
return(false);
}
return(rateLimit.ResetDateTime < DateTime.Now);
}
public async Task WaitForCredentialsRateLimitAsync(IEndpointRateLimit queryRateLimit, IReadOnlyTwitterCredentials credentials, ITwitterExecutionContext executionContext)
{
var timeToWait = GetTimeToWaitFromQueryRateLimit(queryRateLimit, executionContext);
if (timeToWait > TimeSpan.Zero)
{
executionContext.Events.RaiseWaitingForRateLimit(new WaitingForRateLimitEventArgs(null, queryRateLimit, credentials));
await _taskDelayer.Delay(timeToWait).ConfigureAwait(false);
}
}
public TimeSpan GetTimeToWaitFromQueryRateLimit(IEndpointRateLimit queryRateLimit, ITwitterExecutionContext executionContext)
{
if (queryRateLimit == null || queryRateLimit.Remaining > 0)
{
return(TimeSpan.Zero);
}
var timeToWaitInMs = (int)Math.Ceiling(queryRateLimit.ResetDateTimeInMilliseconds) + executionContext.RateLimitWaitFudge.TotalMilliseconds;
return(TimeSpan.FromMilliseconds(timeToWaitInMs));
}
public void TestInitialize()
{
_fakeBuilder = new FakeClassBuilder <RateLimitAwaiter>();
_fakeRateLimitCacheManager = _fakeBuilder.GetFake <IRateLimitCacheManager>();
_fakeCredentialsAccessor = _fakeBuilder.GetFake <ICredentialsAccessor>();
_fakeThreadHelper = _fakeBuilder.GetFake <IThreadHelper>();
_credentials = A.Fake <ITwitterCredentials>();
_endpointRateLimit = A.Fake <IEndpointRateLimit>();
_endpointRateLimit.CallsTo(x => x.Remaining).Returns(0);
_endpointRateLimit.CallsTo(x => x.ResetDateTimeInMilliseconds).Returns(TIME_TO_WAIT);
_fakeRateLimitCacheManager.CallsTo(x => x.GetQueryRateLimit(TEST_QUERY, _credentials)).Returns(_endpointRateLimit);
_fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_credentials);
}
public void TestInitialize()
{
_fakeBuilder = new FakeClassBuilder<RateLimitAwaiter>();
_fakeRateLimitCacheManager = _fakeBuilder.GetFake<IRateLimitCacheManager>();
_fakeCredentialsAccessor = _fakeBuilder.GetFake<ICredentialsAccessor>();
_fakeThreadHelper = _fakeBuilder.GetFake<IThreadHelper>();
_credentials = A.Fake<ITwitterCredentials>();
_endpointRateLimit = A.Fake<IEndpointRateLimit>();
_endpointRateLimit.CallsTo(x => x.Remaining).Returns(0);
_endpointRateLimit.CallsTo(x => x.ResetDateTimeInMilliseconds).Returns(TIME_TO_WAIT);
_fakeRateLimitCacheManager.CallsTo(x => x.GetQueryRateLimit(TEST_QUERY, _credentials)).Returns(_endpointRateLimit);
_fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_credentials);
}
// STATUS [ June 21, 2019 ]: Works (I think) but not sure if needed
/// <summary>
/// From tweetinvi:
/// "Tweetinvi events are global events that can be used to gain more control and debug over what Tweetinvi does for you."
/// </summary>
/// <remarks>
/// From tweetinvi:
/// * Checks which requests will be performed through Tweetinvi
/// More importantly it allows developers to modify or cancel a WebRequest"
/// See: https://github.com/linvi/tweetinvi/wiki/Tweetinvi-Events
/// </remarks>
public void RunPreCheck()
{
TweetinviEvents.QueryBeforeExecute += (sender, args) =>
{
IEndpointRateLimit rateLimits = RateLimit.GetQueryRateLimit(args.QueryURL);
if (rateLimits != null)
{
Console.WriteLine($"\nrateLimits: {rateLimits}"); // 2 - Your code to await for rate limits
}
const bool shouldChangeCredentials = true; // 3 - Your strategy to use multiple credentials
if (shouldChangeCredentials)
{
ITwitterQuery queryDetails = args.TwitterQuery;
Console.WriteLine($"\nqueryDetails: {queryDetails}\n");
}
// 4 - Cancel your query
// args.Cancel = true;
};
}
private void InitializeData()
{
_credentials = A.Fake <ITwitterCredentials>();
_credentials.AccessToken = TestHelper.GenerateString();
_credentials.AccessTokenSecret = TestHelper.GenerateString();
_credentialsRateLimits = A.Fake <ICredentialsRateLimits>();
_endpointRateLimit = A.Fake <IEndpointRateLimit>();
_credentialsRateLimits2 = A.Fake <ICredentialsRateLimits>();
_refreshedCredentialsRateLimits = A.Fake <ICredentialsRateLimits>();
_refreshedEndpointRateLimit = A.Fake <IEndpointRateLimit>();
_endpointRateLimit.CallsTo(x => x.Remaining).Returns(0);
_endpointRateLimit.CallsTo(x => x.ResetDateTime).Returns(DateTime.Now.AddMinutes(1));
_twitterQuery = A.Fake <ITwitterQuery>();
_twitterQuery.CallsTo(x => x.QueryURL).Returns(TEST_QUERY);
_twitterQuery.CallsTo(x => x.HttpMethod).Returns(HttpMethod.GET);
_twitterQuery.CallsTo(x => x.QueryParameters).Returns(Enumerable.Empty <IOAuthQueryParameter>());
}
public void WaitForCredentialsRateLimit(IEndpointRateLimit endpointRateLimit)
{
var timeToWait = GetTimeToWaitFromQueryRateLimit(endpointRateLimit);
Wait(timeToWait);
}
private bool TryPrepareRequest(
IHttpRequestParameters requestParameters,
RateLimitTrackerMode rateLimitTrackerMode,
ITwitterCredentials credentials,
out ITwitterQuery twitterQuery)
{
credentials = credentials ?? _credentialsAccessor.CurrentThreadCredentials;
if (credentials == null)
{
throw new TwitterNullCredentialsException();
}
twitterQuery = _twitterQueryFactory.Create(requestParameters.Query, requestParameters.HttpMethod, credentials);
twitterQuery.HttpContent = requestParameters.HttpContent;
twitterQuery.Timeout = requestParameters.Timeout ?? twitterQuery.Timeout;
var beforeQueryExecuteEventArgs = new QueryBeforeExecuteEventArgs(twitterQuery);
if (rateLimitTrackerMode == RateLimitTrackerMode.TrackOnly ||
rateLimitTrackerMode == RateLimitTrackerMode.TrackAndAwait)
{
// Use the RateLimitCacheManager instead of RateLimitHelper to get the queryRateLimits to ensure the cache is up to date!
var credentialRateLimits = _rateLimitCacheManager.GetCredentialsRateLimits(twitterQuery.TwitterCredentials);
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)
{
queryRateLimit = _rateLimitCacheManager.GetQueryRateLimit(requestParameters.Query, twitterQuery.TwitterCredentials);
}
var timeToWait = _rateLimitAwaiter.GetTimeToWaitFromQueryRateLimit(queryRateLimit);
twitterQuery.CredentialsRateLimits = credentialRateLimits;
twitterQuery.QueryRateLimit = queryRateLimit;
twitterQuery.DateWhenCredentialsWillHaveTheRequiredRateLimits = DateTime.Now.AddMilliseconds(timeToWait);
_tweetinviEvents.RaiseBeforeQueryExecute(beforeQueryExecuteEventArgs);
if (beforeQueryExecuteEventArgs.Cancel)
{
twitterQuery = null;
return(false);
}
if (rateLimitTrackerMode == RateLimitTrackerMode.TrackAndAwait)
{
_rateLimitAwaiter.Wait(timeToWait);
}
}
else
{
_tweetinviEvents.RaiseBeforeQueryExecute(beforeQueryExecuteEventArgs);
if (beforeQueryExecuteEventArgs.Cancel)
{
twitterQuery = null;
return(false);
}
}
_tweetinviEvents.RaiseBeforeExecuteAfterRateLimitAwait(beforeQueryExecuteEventArgs);
return(true);
}
private void InitializeData()
{
_credentials = A.Fake<ITwitterCredentials>();
_endpointRateLimit = A.Fake<IEndpointRateLimit>();
_endpointRateLimit.CallsTo(x => x.Remaining).Returns(5);
}
private void InitializeData()
{
_credentials = A.Fake<ITwitterCredentials>();
_credentials.AccessToken = TestHelper.GenerateString();
_credentials.AccessTokenSecret = TestHelper.GenerateString();
_credentialsRateLimits = A.Fake<ICredentialsRateLimits>();
_endpointRateLimit = A.Fake<IEndpointRateLimit>();
_credentialsRateLimits2 = A.Fake<ICredentialsRateLimits>();
_refreshedCredentialsRateLimits = A.Fake<ICredentialsRateLimits>();
_refreshedEndpointRateLimit = A.Fake<IEndpointRateLimit>();
_endpointRateLimit.CallsTo(x => x.Remaining).Returns(0);
_endpointRateLimit.CallsTo(x => x.ResetDateTime).Returns(DateTime.Now.AddMinutes(1));
_twitterQuery = A.Fake<ITwitterQuery>();
_twitterQuery.CallsTo(x => x.QueryURL).Returns(TEST_QUERY);
_twitterQuery.CallsTo(x => x.HttpMethod).Returns(HttpMethod.GET);
_twitterQuery.CallsTo(x => x.QueryParameters).Returns(Enumerable.Empty<IOAuthQueryParameter>());
}
private bool DoesQueryNeedsToRefreshTheCacheInformation(IEndpointRateLimit rateLimit)
{
return(rateLimit != null && rateLimit.ResetDateTime < DateTime.Now);
}
private void InitializeData()
{
_credentials = A.Fake <ITwitterCredentials>();
_endpointRateLimit = A.Fake <IEndpointRateLimit>();
_endpointRateLimit.CallsTo(x => x.Remaining).Returns(5);
}
/// <summary>
/// Wait for the rate limits to be available. This should be used before executing a query
/// </summary>
public static void AwaitForQueryRateLimit(IEndpointRateLimit endpointRateLimit)
{
RateLimitAwaiter.WaitForCredentialsRateLimit(endpointRateLimit);
}
public Task WaitForQueryRateLimitAsync(IEndpointRateLimit endpointRateLimit)
{
return(_rateLimitAwaiter.WaitForCredentialsRateLimitAsync(endpointRateLimit, _client.Credentials, _client.CreateTwitterExecutionContext()));
}
public void WaitForCredentialsRateLimit(IEndpointRateLimit endpointRateLimit)
{
var timeToWait = GetTimeToWaitFromQueryRateLimit(endpointRateLimit);
Wait(timeToWait);
}
private bool DoesQueryNeedsToRefreshTheCacheInformation(IEndpointRateLimit rateLimit)
{
return rateLimit != null && rateLimit.ResetDateTime < DateTime.Now;
}
/// <summary>
/// Wait for the rate limits to be available. This should be used before executing a query
/// </summary>
public static void AwaitForQueryRateLimit(IEndpointRateLimit endpointRateLimit)
{
RateLimitAwaiter.WaitForCredentialsRateLimit(endpointRateLimit);
}
