/
wrappers.go
118 lines (99 loc) · 3.26 KB
/
wrappers.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
package repotracker
import (
"context"
"time"
"github.com/evergreen-ci/evergreen"
"github.com/evergreen-ci/evergreen/model"
"github.com/evergreen-ci/evergreen/thirdparty"
"github.com/mongodb/grip"
"github.com/mongodb/grip/message"
"github.com/pkg/errors"
)
const (
// the repotracker polls version control (github) for new commits
RunnerName = "repotracker"
// githubAPILimitCeiling is arbitrary but corresponds to when we start logging errors in
// thirdparty/github.go/getGithubRateLimit
githubAPILimitCeiling = 20
)
func getTracker(conf *evergreen.Settings, project model.ProjectRef) (*RepoTracker, error) {
token, err := conf.GetGithubOauthToken()
if err != nil {
grip.Warning(message.Fields{
"runner": RunnerName,
"message": "GitHub credentials not specified in Evergreen credentials file",
})
return nil, errors.WithStack(err)
}
tracker := &RepoTracker{
Settings: conf,
ProjectRef: &project,
RepoPoller: NewGithubRepositoryPoller(&project, token),
}
return tracker, nil
}
func CollectRevisionsForProject(ctx context.Context, conf *evergreen.Settings, project model.ProjectRef) error {
if !project.Enabled || project.IsRepotrackerDisabled() {
return errors.Errorf("project disabled: %s", project.Id)
}
tracker, err := getTracker(conf, project)
if err != nil {
grip.Error(message.WrapError(err, message.Fields{
"project": project.Id,
"project_identifier": project.Identifier,
"message": "problem fetching repotracker",
"runner": RunnerName,
}))
return errors.Wrap(err, "problem fetching repotracker")
}
if err = tracker.FetchRevisions(ctx); err != nil {
grip.Warning(message.WrapError(err, message.Fields{
"project": project.Id,
"project_identifier": project.Identifier,
"message": "problem fetching revisions",
"runner": RunnerName,
}))
return errors.Wrap(err, "repotracker encountered error")
}
return nil
}
func ActivateBuildsForProject(ctx context.Context, project model.ProjectRef, ts time.Time) (bool, error) {
if !project.Enabled {
return false, errors.Errorf("project disabled: %s", project.Id)
}
ok, err := model.DoProjectActivation(ctx, project.Id, ts)
if err != nil {
grip.Warning(message.WrapError(err, message.Fields{
"message": "problem activating recent commit for project",
"runner": RunnerName,
"mode": "catch up",
"project": project.Id,
"project_identifier": project.Identifier,
"timestamp_used": ts,
}))
return false, errors.WithStack(err)
}
return ok, nil
}
// CheckGithubAPIResources returns true when the github API is ready,
// accessible and with sufficient quota to satisfy our needs
func CheckGithubAPIResources(ctx context.Context, githubToken string) bool {
remaining, err := thirdparty.CheckGithubAPILimit(ctx, githubToken)
if err != nil {
grip.Error(message.WrapError(err, message.Fields{
"runner": RunnerName,
"message": "problem checking github api limit",
}))
return false
}
if remaining < githubAPILimitCeiling {
grip.Error(message.Fields{
"runner": RunnerName,
"message": "too few github API requests remaining",
"requests": remaining,
"ceiling": githubAPILimitCeiling,
})
return false
}
return true
}