func allIssuesInRepo(client *github.Client, owner, repo string) []github.Issue {
rate, _, err := client.RateLimits()
if err != nil {
fmt.Printf("error fetching rate limit (%v)\n", err)
} else {
fmt.Printf("API Rate Limit: %s\n", rate)
}
opt := &github.IssueListByRepoOptions{
State: "all",
ListOptions: github.ListOptions{
PerPage: 100,
},
}
var issues []github.Issue
for i := 0; ; i++ {
is, resp, err := client.Issues.ListByRepo(owner, repo, opt)
if err != nil {
fmt.Printf("error listing issues (%v)\n", err)
os.Exit(1)
}
issues = append(issues, is...)
if resp.NextPage == 0 {
break
}
opt.ListOptions.Page = resp.NextPage
fmt.Printf("list %d issues...\n", len(issues))
}
return issues
}
func printRateLimit(client github.Client) {
rate, _, err := client.RateLimit()
if err != nil {
fmt.Println("Error fetching rate limit:", err)
} else {
remaining := int(rate.Reset.Sub(time.Now()).Seconds())
mins := remaining / 60
secs := remaining % 60
fmt.Printf("API Rate Limit: %d/%d remaining for %dm %ds \n\n", rate.Remaining, rate.Limit, mins, secs)
}
}
func AsciiCat(cl *github.Client) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
msg := "Hello, Go In 5 Minutes Viewer!"
cat, _, err := cl.Octocat(msg)
if err != nil {
jsonErr(w, http.StatusInternalServerError, err)
return
}
w.WriteHeader(http.StatusOK)
w.Write([]byte(cat))
})
}
func exceededRateLimit(client *github.Client) bool {
rate, _, err := client.RateLimit()
if err != nil {
fmt.Printf("Error checking rate limit: %s\n", err)
return false
}
// Check for a margin sufficient to run both examples.
if rate.Remaining < 4 {
fmt.Printf("Exceeded (or almost exceeded) GitHub API rate limit: %s. Try again later.\n", rate)
return true
}
return false
}
func GetHookSchema(c *github.Client, name string) (*HookSchema, *github.Response, error) {
req, err := c.NewRequest("GET", fmt.Sprintf("hooks/%v", name), nil)
if err != nil {
return nil, nil, err
}
hookSchema := new(HookSchema)
resp, err := c.Do(req, hookSchema)
if err != nil {
return nil, resp, err
}
return hookSchema, resp, err
}
func GetHookSchemas(c *github.Client) ([]HookSchema, *github.Response, error) {
req, err := c.NewRequest("GET", "hooks", nil)
if err != nil {
return nil, nil, err
}
hookSchemas := new([]HookSchema)
resp, err := c.Do(req, hookSchemas)
if err != nil {
return nil, resp, err
}
return *hookSchemas, resp, err
}
func GitCommitStatuses(client *github.Client, owner, repo, sha string) (interface{}, *github.Response, error) {
u := fmt.Sprintf("repos/%v/%v/commits/%v/statuses", owner, repo, sha)
req, err := client.NewRequest("GET", u, nil)
if err != nil {
return nil, nil, err
}
var c interface{}
resp, err := client.Do(req, &c)
if err != nil {
return nil, resp, err
}
return c, resp, err
}
func simulateAPIRequest(t *testing.T, c *gh.Client) []*http.Request {
var requests []*http.Request
mux := http.NewServeMux()
mux.HandleFunc("/rate_limit", func(w http.ResponseWriter, req *http.Request) {
requests = append(requests, req)
w.Write([]byte("{}"))
})
srv := httptest.NewServer(mux)
defer srv.Close()
c.BaseURL, _ = url.Parse(srv.URL)
if _, _, err := c.RateLimits(); err != nil {
t.Fatalf("failed to retrieve rate limits; %v", err)
}
return requests
}
func PutGitCommitStatus(client *github.Client, owner, repo, sha string, body *CommitStatus) (interface{}, *github.Response, error) {
u := fmt.Sprintf("repos/%v/%v/statuses/%v", owner, repo, sha)
if body == nil {
body = &CommitStatus{}
}
req, err := client.NewRequest("POST", u, body)
if err != nil {
return nil, nil, err
}
var c interface{}
resp, err := client.Do(req, c)
if err != nil {
return nil, resp, err
}
return c, resp, err
}
func DownloadAsset(client *github.Client, asset *github.ReleaseAsset) error {
req, _ := client.NewRequest("GET", *asset.URL, nil)
req.Header.Set("Accept", "application/octet-stream")
apiResponse, err := client.Do(req, nil)
assetResponse, err := http.Get(apiResponse.Response.Request.URL.String())
if err != nil {
return err
}
f, err := os.Create(flags.Output)
if err != nil {
return err
}
defer f.Close()
io.Copy(f, assetResponse.Body)
return nil
}