Module org.kohsuke.github.api

Package org.kohsuke.github

Class RateLimitChecker

java.lang.Object

org.kohsuke.github.RateLimitChecker

Direct Known Subclasses:

RateLimitChecker.LiteralValue

public abstract class RateLimitChecker
extends Object

A GitHub API Rate Limit Checker called before each request

GitHub allots a certain number of requests to each user or application per period of time. The number of requests remaining and the time when the number will be reset is returned in the response header and can also be requested using GitHub.getRateLimit(). The "requests per interval" is referred to as the "rate limit".

GitHub prefers that clients stop before exceeding their rate limit rather than stopping after they exceed it. The RateLimitChecker is called before each request to check the rate limit and wait if the checker criteria are met.

Author:

Liam Newman

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	RateLimitChecker.LiteralValue	A RateLimitChecker with a simple number as the limit.

Field Summary

Fields

Modifier and Type	Field	Description
static final RateLimitChecker	NONE	The Constant NONE.

Constructor Summary

Constructors

Constructor	Description
RateLimitChecker()	Create default RateLimitChecker instance

Method Summary

Modifier and Type	Method	Description
protected boolean	checkRateLimit(GHRateLimit.Record rateLimitRecord, long count)	Decides whether the current request exceeds the allowed "rate limit" budget.
protected final boolean	sleepUntilReset(GHRateLimit.Record record)	Sleep until reset.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

NONE

public static final RateLimitChecker NONE

The Constant NONE.

Constructor Details

RateLimitChecker

public RateLimitChecker()

Create default RateLimitChecker instance

Method Details

checkRateLimit

protected boolean checkRateLimit(GHRateLimit.Record rateLimitRecord,
 long count)
                          throws InterruptedException

Decides whether the current request exceeds the allowed "rate limit" budget. If this determines the rate limit will be exceeded, this method should sleep for some amount of time and must return true. Implementers are free to choose whatever strategy they prefer for what is considered to exceed the budget and how long to sleep.

The caller of this method figures out which GHRateLimit.Record applies for the current request and provides it to this method.

As long as this method returns true it is guaranteed that GitHubRateLimitChecker will retrieve updated rate limit information and call this method again with count incremented by one. When this checker returns false, the calling GitHubRateLimitChecker will let the request continue.

Rate limit reset times are only accurate to the second. Trying to sleep to exactly the reset time could result in requests being sent before the new rate limit was available. For this reason, if this method returned true at least once for a particular request, GitHubRateLimitChecker may choose to sleep for some small additional between calls and before letting the request continue.

Parameters:

rateLimitRecord - the current GHRateLimit.Record to check against.

count - the number of times in a row this method has been called for the current request

Returns:

false if the current request does not exceed the allowed budget, true if the current request exceeded the budget.

Throws:

InterruptedException - if the thread is interrupted while sleeping

sleepUntilReset

protected final boolean sleepUntilReset(GHRateLimit.Record record)
                                 throws InterruptedException

Sleep until reset.

Parameters:

record - the record

Returns:

true, if successful

Throws:

InterruptedException - the interrupted exception