//NOTE: This application doesn't implement the OAuth flow due to readability of secrets, therefore this is basically useless.
public static int AuthCached()
{
string token = App.Default.GitToken;
if (!String.IsNullOrEmpty(token))
{
try {
Credentials auth = new Credentials(token);
git.Credentials = auth;
MiscellaneousRateLimit rates = git.Miscellaneous.GetRateLimits().Result;
if (rates.Rate.Limit > 60)
{
return(rates.Rate.Remaining);
}
else
{
return(-1);
}
} catch (Exception) {
return(-1);
}
}
else
{
return(-1);
}
}
private void WriteRateLimit(MiscellaneousRateLimit rateLimitInfo)
{
var coreRateLimit = rateLimitInfo.Resources.Core;
Log.Debug($"RateLimit (Core): {coreRateLimit.Remaining}/{coreRateLimit.Limit}; Reset at {coreRateLimit.Reset:yyyy-MM-dd HH:mm:ss,fff}");
var searchRateLimit = rateLimitInfo.Resources.Search;
Log.Info($"RateLimit (Search): {searchRateLimit.Remaining}/{searchRateLimit.Limit}; Reset at {searchRateLimit.Reset:yyyy-MM-dd HH:mm:ss,fff}");
}
private static double TranslateRateLimits(MiscellaneousRateLimit rateLimits)
{
RateLimit CoreRateLimit = rateLimits.Resources.Core;
RateLimit SearchRateLimit = rateLimits.Resources.Search;
double CoreRatio = (1.0 * CoreRateLimit.Remaining) / CoreRateLimit.Limit;
double SearchRatio = (1.0 * SearchRateLimit.Remaining) / SearchRateLimit.Limit;
double MinRatio = Math.Min(CoreRatio, SearchRatio);
return(MinRatio);
}
public async Task RequestsTheResourceRateLimitEndpoint()
{
var rateLimit = new MiscellaneousRateLimit(
new ResourceRateLimit(
new RateLimit(5000, 4999, 1372700873),
new RateLimit(30, 18, 1372700873)
),
new RateLimit(100, 75, 1372700873)
);
var apiConnection = Substitute.For <IApiConnection>();
apiConnection.Get <MiscellaneousRateLimit>(Arg.Is <Uri>(u => u.ToString() == "rate_limit")).Returns(Task.FromResult(rateLimit));
var client = new MiscellaneousClient(apiConnection);
var result = await client.GetRateLimits();
// Test the core limits
Assert.Equal(5000, result.Resources.Core.Limit);
Assert.Equal(4999, result.Resources.Core.Remaining);
Assert.Equal(1372700873, result.Resources.Core.ResetAsUtcEpochSeconds);
var expectedReset = DateTimeOffset.ParseExact(
"Mon 01 Jul 2013 5:47:53 PM -00:00",
"ddd dd MMM yyyy h:mm:ss tt zzz",
CultureInfo.InvariantCulture);
Assert.Equal(expectedReset, result.Resources.Core.Reset);
// Test the search limits
Assert.Equal(30, result.Resources.Search.Limit);
Assert.Equal(18, result.Resources.Search.Remaining);
Assert.Equal(1372700873, result.Resources.Search.ResetAsUtcEpochSeconds);
expectedReset = DateTimeOffset.ParseExact(
"Mon 01 Jul 2013 5:47:53 PM -00:00",
"ddd dd MMM yyyy h:mm:ss tt zzz",
CultureInfo.InvariantCulture);
Assert.Equal(expectedReset, result.Resources.Search.Reset);
// Test the depreciated rate limits
Assert.Equal(100, result.Rate.Limit);
Assert.Equal(75, result.Rate.Remaining);
Assert.Equal(1372700873, result.Rate.ResetAsUtcEpochSeconds);
expectedReset = DateTimeOffset.ParseExact(
"Mon 01 Jul 2013 5:47:53 PM -00:00",
"ddd dd MMM yyyy h:mm:ss tt zzz",
CultureInfo.InvariantCulture);
Assert.Equal(expectedReset, result.Rate.Reset);
apiConnection.Received()
.Get <MiscellaneousRateLimit>(Arg.Is <Uri>(u => u.ToString() == "rate_limit"));
}
private static async Task <double> GetRemainingRequests()
{
try
{
MiscellaneousRateLimit RateLimits = await Client.Miscellaneous.GetRateLimits();
return(TranslateRateLimits(RateLimits));
}
catch (ApiException exception)
{
Debug.WriteLine($"GitHub: {exception.Message}");
return(0);
}
}
public async Task <TResult> GetAsync <TResult>(Func <GitHubClient, Task <TResult> > func, IExecutionContext context, bool retry = true)
{
AsyncRetryPolicy <TResult> retryPolicy = null;
if (retry)
{
retryPolicy = Policy <TResult>
.Handle <ApiException>()
.WaitAndRetryAsync(MaxRetry, attempt =>
{
context.LogInformation($"GitHub retry {attempt}");
return(TimeSpan.FromSeconds(1 * Math.Pow(2, attempt)));
});
}
await _semaphore.WaitAsync();
try
{
TResult result = retry
? await retryPolicy.ExecuteAsync(async _ => await func(_gitHub), context.CancellationToken)
: await func(_gitHub);
try
{
MiscellaneousRateLimit rateLimit = await _gitHub.Miscellaneous.GetRateLimits();
context.LogInformation($"GitHub rate limit: {rateLimit.Resources.Core.Remaining} remaining");
}
catch (Exception)
{
// Eat exceptions when getting rate limits
}
return(result);
}
finally
{
_semaphore.Release();
}
}
private async Task UpdateRateLimit()
{
var now = DateTimeOffset.Now;
var isInitialCall = _rateLimit == null;
if (!isInitialCall)
{
var difference = now - _lastRateLimit;
if (difference < TimeSpan.FromSeconds(30))
{
return;
}
}
_rateLimit = await _client.Miscellaneous.GetRateLimits();
_lastRateLimit = now;
if (isInitialCall)
{
_lastApiRemaining = _rateLimit.Resources.Core.Remaining;
}
var apiRemainingDifference = _rateLimit.Resources.Core.Remaining - _lastApiRemaining;
_apiRemainingDifference += apiRemainingDifference;
_lastApiRemaining = _rateLimit.Resources.Core.Remaining;
if (_apiRemainingDifference < 0)
{
_currentDelay += TimeSpan.FromSeconds(0.5);
}
else if (_apiRemainingDifference > 0)
{
_currentDelay -= TimeSpan.FromSeconds(0.5);
if (_currentDelay < _minTimeSpan)
{
_currentDelay = _minTimeSpan;
}
}
}
private async Task WaitForApiLimit(bool search = false)
{
//check if local managed limit exceeded!
if (search && _searchLimit == 0 || !search && _rateLimit == 0)
{
//update local values in case of limit reset after time
MiscellaneousRateLimit limits = await _gitHubClient.Miscellaneous.GetRateLimits();
//if a limit is really exceeded!
while (search && limits.Resources.Search.Remaining == 0)
{
WaitUntil(limits.Resources.Search.Reset);
limits = await _gitHubClient.Miscellaneous.GetRateLimits();
}
while (!search && limits.Resources.Core.Remaining == 0)
{
WaitUntil(limits.Resources.Core.Reset);
limits = await _gitHubClient.Miscellaneous.GetRateLimits();
}
// store the new limits
_searchLimit = limits.Resources.Search.Remaining;
_rateLimit = limits.Resources.Core.Remaining;
}
// decrease the limit for the action
if (search)
{
_searchLimit--;
}
else
{
_rateLimit--;
}
}
public static int Auth(string username, string password)
{
try {
Credentials auth = new Credentials(username, password);
git.Credentials = auth;
MiscellaneousRateLimit rates = git.Miscellaneous.GetRateLimits().Result;
if (rates.Rate.Limit > 60)
{
if (AllowUnsafeGithubAuth)
{
App.Default.GitUsername = username;
App.Default.GitPassword = password;
App.Default.Save();
}
return(rates.Rate.Remaining);
}
else
{
return(-1);
}
} catch (Exception) {
return(-1);
}
}
private async void OnGetRateLimitsClick(object sender, EventArgs e)
{
if (client == null)
{
WriteLineInfo(NL + "Get Rate Limits: No client defined");
return;
}
MiscellaneousRateLimit miscellaneousRateLimit = await client.Miscellaneous.GetRateLimits();
// The "core" object provides your rate limit status except for the Search API.
RateLimit coreRateLimit = miscellaneousRateLimit.Resources.Core;
RateLimit searchRateLimit = miscellaneousRateLimit.Resources.Search;
StringBuilder builder = new StringBuilder(NL + "Rate Limits");
builder.AppendLine("Core");
builder.AppendLine($" Limit={coreRateLimit.Limit}");
builder.AppendLine($" Remaining={coreRateLimit.Remaining}");
builder.AppendLine($" Reset={coreRateLimit.Reset.ToLocalTime()}");
builder.AppendLine("Search");
builder.AppendLine($" Limit={searchRateLimit.Limit}");
builder.AppendLine($" Remaining={searchRateLimit.Remaining}");
builder.AppendLine($" Reset={searchRateLimit.Reset.ToLocalTime()}");
WriteInfo(builder.ToString());
}
