_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q176300 | clearStaleComments | test | func clearStaleComments(gc githubClient, log *logrus.Entry, pr *github.PullRequestEvent, prLabels sets.String, comments []github.IssueComment) error {
// If the PR must follow the process and hasn't yet completed the process, don't remove comments.
if prMustFollowRelNoteProcess(gc, log, pr, prLabels, false) && !relea... | go | {
"resource": ""
} |
q176301 | determineReleaseNoteLabel | test | func determineReleaseNoteLabel(body string) string {
composedReleaseNote := strings.ToLower(strings.TrimSpace(getReleaseNote(body)))
if composedReleaseNote == "" {
return ReleaseNoteLabelNeeded
}
if noneRe.MatchString(composedReleaseNote) {
return releaseNoteNone
}
if strings.Contains(composedReleaseNote, ac... | go | {
"resource": ""
} |
q176302 | getReleaseNote | test | func getReleaseNote(body string) string {
potentialMatch := noteMatcherRE.FindStringSubmatch(body)
if potentialMatch == nil {
return ""
}
return strings.TrimSpace(potentialMatch[1])
} | go | {
"resource": ""
} |
q176303 | NewClient | test | func NewClient(boskosClient boskosClient) *Client {
return &Client{
basic: boskosClient,
resources: map[string]common.Resource{},
}
} | go | {
"resource": ""
} |
q176304 | Acquire | test | func (c *Client) Acquire(rtype, state, dest string) (*common.Resource, error) {
var resourcesToRelease []common.Resource
releaseOnFailure := func() {
for _, r := range resourcesToRelease {
if err := c.basic.ReleaseOne(r.Name, common.Dirty); err != nil {
logrus.WithError(err).Warningf("failed to release resou... | go | {
"resource": ""
} |
q176305 | ReleaseOne | test | func (c *Client) ReleaseOne(name, dest string) (allErrors error) {
res, err := c.getResource(name)
if err != nil {
allErrors = err
return
}
resourceNames := []string{name}
var leasedResources common.LeasedResources
if err := res.UserData.Extract(LeasedResources, &leasedResources); err != nil {
if _, ok := e... | go | {
"resource": ""
} |
q176306 | UpdateAll | test | func (c *Client) UpdateAll(state string) error {
return c.basic.UpdateAll(state)
} | go | {
"resource": ""
} |
q176307 | GetGitHubClient | test | func GetGitHubClient(token string) *github.Client {
return github.NewClient(
oauth2.NewClient(
oauth2.NoContext,
oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token}),
),
)
} | go | {
"resource": ""
} |
q176308 | GetUsername | test | func GetUsername(client *github.Client) (string, error) {
user, _, err := client.Users.Get(context.Background(), "")
if err != nil {
return "", err
}
if user.Login == nil {
return "", errors.New("Users.Get(\"\") returned empty login")
}
return *user.Login, nil
} | go | {
"resource": ""
} |
q176309 | CreateTokenHandler | test | func CreateTokenHandler(tokenStream io.Reader, influxdb *InfluxDB) (*TokenHandler, error) {
token, err := ioutil.ReadAll(tokenStream)
if err != nil {
return nil, err
}
client := GetGitHubClient(strings.TrimSpace(string(token)))
login, err := GetUsername(client) // Get user name for token
if err != nil {
retur... | go | {
"resource": ""
} |
q176310 | CreateTokenHandlers | test | func CreateTokenHandlers(tokenFiles []string, influxdb *InfluxDB) ([]TokenHandler, error) {
tokens := []TokenHandler{}
for _, tokenFile := range tokenFiles {
f, err := os.Open(tokenFile)
if err != nil {
return nil, fmt.Errorf("Can't open token-file (%s): %s", tokenFile, err)
}
token, err := CreateTokenHand... | go | {
"resource": ""
} |
q176311 | String | test | func (i *jobIndentifier) String() string {
return fmt.Sprintf("%s %s/%s#%d", i.job, i.organization, i.repository, i.pullRequest)
} | go | {
"resource": ""
} |
q176312 | TerminateOlderPresubmitJobs | test | func TerminateOlderPresubmitJobs(pjc prowClient, log *logrus.Entry, pjs []prowapi.ProwJob,
cleanup ProwJobResourcesCleanup) error {
dupes := map[jobIndentifier]int{}
for i, pj := range pjs {
if pj.Complete() || pj.Spec.Type != prowapi.PresubmitJob {
continue
}
ji := jobIndentifier{
job: pj.Spec... | go | {
"resource": ""
} |
q176313 | PushMetrics | test | func PushMetrics(component, endpoint string, interval time.Duration) {
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
for {
select {
case <-time.Tick(interval):
if err := push.FromGatherer(component, push.HostnameGroupingKey(), endpoint, prometheus.DefaultGatherer); err != n... | go | {
"resource": ""
} |
q176314 | RateLimiter | test | func RateLimiter(controllerName string) workqueue.RateLimitingInterface {
rl := workqueue.NewMaxOfRateLimiter(
workqueue.NewItemExponentialFailureRateLimiter(5*time.Millisecond, 120*time.Second),
&workqueue.BucketRateLimiter{Limiter: rate.NewLimiter(rate.Limit(1000), 50000)},
)
return workqueue.NewNamedRateLimit... | go | {
"resource": ""
} |
q176315 | checkExistingStatus | test | func checkExistingStatus(gc gitHubClient, l *logrus.Entry, org, repo, sha string) (string, error) {
statuses, err := gc.ListStatuses(org, repo, sha)
if err != nil {
return "", fmt.Errorf("error listing pull request statuses: %v", err)
}
existingStatus := ""
for _, status := range statuses {
if status.Context ... | go | {
"resource": ""
} |
q176316 | checkExistingLabels | test | func checkExistingLabels(gc gitHubClient, l *logrus.Entry, org, repo string, number int) (hasYesLabel, hasNoLabel bool, err error) {
labels, err := gc.GetIssueLabels(org, repo, number)
if err != nil {
return false, false, fmt.Errorf("error getting pull request labels: %v", err)
}
for _, l := range labels {
if ... | go | {
"resource": ""
} |
q176317 | handle | test | func handle(gc gitHubClient, cp commentPruner, log *logrus.Entry, org, repo string, pr github.PullRequest, addComment bool) error {
l := log.WithField("pr", pr.Number)
commitsMissingDCO, err := checkCommitMessages(gc, l, org, repo, pr.Number)
if err != nil {
l.WithError(err).Infof("Error running DCO check against... | go | {
"resource": ""
} |
q176318 | MarkdownSHAList | test | func MarkdownSHAList(org, repo string, list []github.GitCommit) string {
lines := make([]string, len(list))
lineFmt := "- [%s](https://github.com/%s/%s/commits/%s) %s"
for i, commit := range list {
if commit.SHA == "" {
continue
}
// if we somehow encounter a SHA that's less than 7 characters, we will
// ... | go | {
"resource": ""
} |
q176319 | PathForSpec | test | func PathForSpec(spec *downwardapi.JobSpec, pathSegment RepoPathBuilder) string {
switch spec.Type {
case prowapi.PeriodicJob, prowapi.PostsubmitJob:
return path.Join(NonPRLogs, spec.Job, spec.BuildID)
case prowapi.PresubmitJob:
return path.Join(PRLogs, "pull", pathSegment(spec.Refs.Org, spec.Refs.Repo), strconv... | go | {
"resource": ""
} |
q176320 | AliasForSpec | test | func AliasForSpec(spec *downwardapi.JobSpec) string {
switch spec.Type {
case prowapi.PeriodicJob, prowapi.PostsubmitJob, prowapi.BatchJob:
return ""
case prowapi.PresubmitJob:
return path.Join(PRLogs, "directory", spec.Job, fmt.Sprintf("%s.txt", spec.BuildID))
default:
logrus.Fatalf("unknown job spec type: %... | go | {
"resource": ""
} |
q176321 | RootForSpec | test | func RootForSpec(spec *downwardapi.JobSpec) string {
switch spec.Type {
case prowapi.PeriodicJob, prowapi.PostsubmitJob:
return path.Join(NonPRLogs, spec.Job)
case prowapi.PresubmitJob, prowapi.BatchJob:
return path.Join(PRLogs, "directory", spec.Job)
default:
logrus.Errorf("unknown job spec type: %v", spec.T... | go | {
"resource": ""
} |
q176322 | NewSingleDefaultRepoPathBuilder | test | func NewSingleDefaultRepoPathBuilder(defaultOrg, defaultRepo string) RepoPathBuilder {
return func(org, repo string) string {
if org == defaultOrg && repo == defaultRepo {
return ""
}
// handle gerrit repo
repo = strings.Replace(repo, "/", "_", -1)
return fmt.Sprintf("%s_%s", org, repo)
}
} | go | {
"resource": ""
} |
q176323 | NewExplicitRepoPathBuilder | test | func NewExplicitRepoPathBuilder() RepoPathBuilder {
return func(org, repo string) string {
// handle gerrit repo
repo = strings.Replace(repo, "/", "_", -1)
return fmt.Sprintf("%s_%s", org, repo)
}
} | go | {
"resource": ""
} |
q176324 | RegisterSourceOrDie | test | func RegisterSourceOrDie(name string, src IssueSource) {
if _, ok := sources[name]; ok {
glog.Fatalf("Cannot register an IssueSource with name %q, already exists!", name)
}
sources[name] = src
glog.Infof("Registered issue source '%s'.", name)
} | go | {
"resource": ""
} |
q176325 | CreateAndSync | test | func (c *IssueCreator) CreateAndSync() {
var err error
if err = c.initialize(); err != nil {
glog.Fatalf("Error initializing IssueCreator: %v.", err)
}
glog.Info("IssueCreator initialization complete.")
for srcName, src := range sources {
glog.Infof("Generating issues from source: %s.", srcName)
var issues ... | go | {
"resource": ""
} |
q176326 | loadCache | test | func (c *IssueCreator) loadCache() error {
user, err := c.client.GetUser("")
if err != nil {
return fmt.Errorf("failed to fetch the User struct for the current authenticated user. errmsg: %v", err)
}
if user == nil {
return fmt.Errorf("received a nil User struct pointer when trying to look up the currently auth... | go | {
"resource": ""
} |
q176327 | setIntersect | test | func setIntersect(a, b []string) (filtered, removed []string) {
for _, elemA := range a {
found := false
for _, elemB := range b {
if elemA == elemB {
found = true
break
}
}
if found {
filtered = append(filtered, elemA)
} else {
removed = append(removed, elemA)
}
}
return
} | go | {
"resource": ""
} |
q176328 | sync | test | func (c *IssueCreator) sync(issue Issue) bool {
// First look for existing issues with this ID.
id := issue.ID()
var closedIssues []*github.Issue
for _, i := range c.allIssues {
if strings.Contains(*i.Body, id) {
switch *i.State {
case "open":
//if an open issue is found with the ID then the issue is al... | go | {
"resource": ""
} |
q176329 | GetAWSCreds | test | func GetAWSCreds(r *common.Resource) (credentials.Value, error) {
val := credentials.Value{}
if r.Type != ResourceType {
return val, fmt.Errorf("Wanted resource of type %q, got %q", ResourceType, r.Type)
}
accessKey, ok := r.UserData.Map.Load(UserDataAccessIDKey)
if !ok {
return val, errors.New("No Access Ke... | go | {
"resource": ""
} |
q176330 | stopper | test | func stopper() chan struct{} {
stop := make(chan struct{})
c := make(chan os.Signal, 2)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
go func() {
<-c
logrus.Warn("Interrupt received, attempting clean shutdown...")
close(stop)
<-c
logrus.Error("Second interrupt received, force exiting...")
os.Exit(1)
... | go | {
"resource": ""
} |
q176331 | newPipelineConfig | test | func newPipelineConfig(cfg rest.Config, stop chan struct{}) (*pipelineConfig, error) {
bc, err := pipelineset.NewForConfig(&cfg)
if err != nil {
return nil, err
}
// Ensure the pipeline CRD is deployed
// TODO(fejta): probably a better way to do this
if _, err := bc.TektonV1alpha1().PipelineRuns("").List(metav... | go | {
"resource": ""
} |
q176332 | KubeClient | test | func (o *KubernetesClientOptions) KubeClient() (kubernetes.Interface, error) {
return kube.GetKubernetesClient(o.masterURL, o.kubeConfig)
} | go | {
"resource": ""
} |
q176333 | ProwJobClient | test | func (o *KubernetesClientOptions) ProwJobClient() (versioned.Interface, error) {
return kube.GetProwJobClient(o.masterURL, o.kubeConfig)
} | go | {
"resource": ""
} |
q176334 | resolveSymLink | test | func (bucket gcsBucket) resolveSymLink(symLink string) (string, error) {
data, err := bucket.readObject(symLink)
if err != nil {
return "", fmt.Errorf("failed to read %s: %v", symLink, err)
}
// strip gs://<bucket-name> from global address `u`
u := string(data)
return prefixRe.ReplaceAllString(u, ""), nil
} | go | {
"resource": ""
} |
q176335 | readJSON | test | func readJSON(bucket storageBucket, key string, data interface{}) error {
rawData, err := bucket.readObject(key)
if err != nil {
return fmt.Errorf("failed to read %s: %v", key, err)
}
err = json.Unmarshal(rawData, &data)
if err != nil {
return fmt.Errorf("failed to parse %s: %v", key, err)
}
return nil
} | go | {
"resource": ""
} |
q176336 | listSubDirs | test | func (bucket gcsBucket) listSubDirs(prefix string) ([]string, error) {
if !strings.HasSuffix(prefix, "/") {
prefix += "/"
}
dirs := []string{}
it := bucket.Objects(context.Background(), &storage.Query{
Prefix: prefix,
Delimiter: "/",
})
for {
attrs, err := it.Next()
if err == iterator.Done {
break... | go | {
"resource": ""
} |
q176337 | listAll | test | func (bucket gcsBucket) listAll(prefix string) ([]string, error) {
keys := []string{}
it := bucket.Objects(context.Background(), &storage.Query{
Prefix: prefix,
})
for {
attrs, err := it.Next()
if err == iterator.Done {
break
}
if err != nil {
return keys, err
}
keys = append(keys, attrs.Name)
... | go | {
"resource": ""
} |
q176338 | listBuildIDs | test | func (bucket gcsBucket) listBuildIDs(root string) ([]int64, error) {
ids := []int64{}
if strings.HasPrefix(root, logsPrefix) {
dirs, err := bucket.listSubDirs(root)
if err != nil {
return ids, fmt.Errorf("failed to list GCS directories: %v", err)
}
for _, dir := range dirs {
i, err := strconv.ParseInt(p... | go | {
"resource": ""
} |
q176339 | FilterProfilePaths | test | func FilterProfilePaths(profile []*cover.Profile, paths []string, include bool) ([]*cover.Profile, error) {
parenPaths := make([]string, len(paths))
for i, path := range paths {
parenPaths[i] = "(" + path + ")"
}
joined := strings.Join(parenPaths, "|")
re, err := regexp.Compile(joined)
if err != nil {
return ... | go | {
"resource": ""
} |
q176340 | LoadSecrets | test | func LoadSecrets(paths []string) (map[string][]byte, error) {
secretsMap := make(map[string][]byte, len(paths))
for _, path := range paths {
secretValue, err := LoadSingleSecret(path)
if err != nil {
return nil, err
}
secretsMap[path] = secretValue
}
return secretsMap, nil
} | go | {
"resource": ""
} |
q176341 | LoadSingleSecret | test | func LoadSingleSecret(path string) ([]byte, error) {
b, err := ioutil.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("error reading %s: %v", path, err)
}
return bytes.TrimSpace(b), nil
} | go | {
"resource": ""
} |
q176342 | Set | test | func (b *Bool) Set(s string) error {
v, err := strconv.ParseBool(s)
if err != nil {
return err
}
b.Explicit = true
b.Value = v
return nil
} | go | {
"resource": ""
} |
q176343 | NewOpener | test | func NewOpener(ctx context.Context, creds string) (Opener, error) {
var options []option.ClientOption
if creds != "" {
options = append(options, option.WithCredentialsFile(creds))
}
client, err := storage.NewClient(ctx, options...)
if err != nil {
if creds != "" {
return nil, err
}
logrus.WithError(err)... | go | {
"resource": ""
} |
q176344 | IsNotExist | test | func IsNotExist(err error) bool {
return os.IsNotExist(err) || err == storage.ErrObjectNotExist
} | go | {
"resource": ""
} |
q176345 | LogClose | test | func LogClose(c io.Closer) {
if err := c.Close(); err != nil {
logrus.WithError(err).Error("Failed to close")
}
} | go | {
"resource": ""
} |
q176346 | Writer | test | func (o opener) Writer(ctx context.Context, path string) (io.WriteCloser, error) {
g, err := o.openGCS(path)
if err != nil {
return nil, fmt.Errorf("bad gcs path: %v", err)
}
if g == nil {
return os.Create(path)
}
return g.NewWriter(ctx), nil
} | go | {
"resource": ""
} |
q176347 | InitGitHubOAuthConfig | test | func (gac *GitHubOAuthConfig) InitGitHubOAuthConfig(cookie *sessions.CookieStore) {
gob.Register(&oauth2.Token{})
gac.CookieStore = cookie
} | go | {
"resource": ""
} |
q176348 | deltaDisplayed | test | func deltaDisplayed(change *coverageChange) string {
if change.baseRatio < 0 {
return ""
}
return fmt.Sprintf("%.1f", (change.newRatio-change.baseRatio)*100)
} | go | {
"resource": ""
} |
q176349 | makeTable | test | func makeTable(baseCovList, newCovList *calculation.CoverageList, coverageThreshold float32) (string, bool) {
var rows []string
isCoverageLow := false
for _, change := range findChanges(baseCovList, newCovList) {
filePath := change.name
rows = append(rows, fmt.Sprintf("%s | %s | %s | %s",
filePath,
formatP... | go | {
"resource": ""
} |
q176350 | ContentForGitHubPost | test | func ContentForGitHubPost(baseProfiles, newProfiles []*cover.Profile, jobName string, coverageThreshold float32) (
string, bool) {
rows := []string{
"The following is the code coverage report",
fmt.Sprintf("Say `/test %s` to re-run this coverage report", jobName),
"",
"File | Old Coverage | New Coverage | De... | go | {
"resource": ""
} |
q176351 | AddFlags | test | func (client *Client) AddFlags(cmd *cobra.Command) {
cmd.PersistentFlags().StringVar(&client.Token, "token", "",
"The OAuth Token to use for requests.")
cmd.PersistentFlags().StringVar(&client.TokenFile, "token-file", "",
"The file containing the OAuth Token to use for requests.")
cmd.PersistentFlags().StringVar... | go | {
"resource": ""
} |
q176352 | CheckFlags | test | func (client *Client) CheckFlags() error {
if client.Org == "" {
return fmt.Errorf("organization flag must be set")
}
client.Org = strings.ToLower(client.Org)
if client.Project == "" {
return fmt.Errorf("project flag must be set")
}
client.Project = strings.ToLower(client.Project)
return nil
} | go | {
"resource": ""
} |
q176353 | getGitHubClient | test | func (client *Client) getGitHubClient() (*github.Client, error) {
if client.githubClient != nil {
return client.githubClient, nil
}
token := client.Token
if len(token) == 0 && len(client.TokenFile) != 0 {
data, err := ioutil.ReadFile(client.TokenFile)
if err != nil {
return nil, err
}
token = strings.T... | go | {
"resource": ""
} |
q176354 | limitsCheckAndWait | test | func (client *Client) limitsCheckAndWait() {
var sleep time.Duration
githubClient, err := client.getGitHubClient()
if err != nil {
glog.Error("Failed to get RateLimits: ", err)
sleep = time.Minute
} else {
limits, _, err := githubClient.RateLimits(context.Background())
if err != nil {
glog.Error("Failed ... | go | {
"resource": ""
} |
q176355 | FetchIssues | test | func (client *Client) FetchIssues(latest time.Time, c chan *github.Issue) {
opt := &github.IssueListByRepoOptions{Since: latest, Sort: "updated", State: "all", Direction: "asc"}
githubClient, err := client.getGitHubClient()
if err != nil {
close(c)
glog.Error(err)
return
}
count := 0
for {
client.limits... | go | {
"resource": ""
} |
q176356 | hasID | test | func hasID(events []*github.IssueEvent, id int) bool {
for _, event := range events {
if *event.ID == int64(id) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q176357 | FetchIssueEvents | test | func (client *Client) FetchIssueEvents(issueID int, latest *int, c chan *github.IssueEvent) {
opt := &github.ListOptions{PerPage: 100}
githubClient, err := client.getGitHubClient()
if err != nil {
close(c)
glog.Error(err)
return
}
count := 0
for {
client.limitsCheckAndWait()
events, resp, err := gith... | go | {
"resource": ""
} |
q176358 | isPRChanged | test | func isPRChanged(pe github.PullRequestEvent) bool {
switch pe.Action {
case github.PullRequestActionOpened:
return true
case github.PullRequestActionReopened:
return true
case github.PullRequestActionSynchronize:
return true
case github.PullRequestActionEdited:
return true
default:
return false
}
} | go | {
"resource": ""
} |
q176359 | NewFetcher | test | func NewFetcher(repository string) *Fetcher {
return &Fetcher{
IssuesChannel: make(chan sql.Issue, 100),
EventsCommentsChannel: make(chan interface{}, 100),
repository: repository,
}
} | go | {
"resource": ""
} |
q176360 | fetchRecentIssues | test | func (f *Fetcher) fetchRecentIssues(db *gorm.DB) error {
glog.Infof("Fetching issues updated after %s", f.lastIssue)
var issues []sql.Issue
query := db.
Where("issue_updated_at >= ?", f.lastIssue).
Where("repository = ?", f.repository).
Order("issue_updated_at").
Preload("Labels").
Find(&issues)
if query... | go | {
"resource": ""
} |
q176361 | fetchRecentEventsAndComments | test | func (f *Fetcher) fetchRecentEventsAndComments(db *gorm.DB) error {
glog.Infof("Fetching issue-events with id bigger than %s", f.lastEvent)
glog.Infof("Fetching comments with id bigger than %s", f.lastComment)
eventRows, err := db.
Model(sql.IssueEvent{}).
Where("repository = ?", f.repository).
Where("event_c... | go | {
"resource": ""
} |
q176362 | Fetch | test | func (f *Fetcher) Fetch(db *gorm.DB) error {
if err := f.fetchRecentIssues(db); err != nil {
return err
}
if err := f.fetchRecentEventsAndComments(db); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176363 | Issues | test | func (fjr *FlakyJobReporter) Issues(c *creator.IssueCreator) ([]creator.Issue, error) {
fjr.creator = c
json, err := ReadHTTP(fjr.flakyJobDataURL)
if err != nil {
return nil, err
}
flakyJobs, err := fjr.parseFlakyJobs(json)
if err != nil {
return nil, err
}
count := fjr.syncCount
if len(flakyJobs) < coun... | go | {
"resource": ""
} |
q176364 | Title | test | func (fj *FlakyJob) Title() string {
return fmt.Sprintf("%s flaked %d times in the past week", fj.Name, *fj.FlakeCount)
} | go | {
"resource": ""
} |
q176365 | Labels | test | func (fj *FlakyJob) Labels() []string {
labels := []string{"kind/flake"}
// get sig labels
for sig := range fj.reporter.creator.TestsSIGs(fj.TestsSorted()) {
labels = append(labels, "sig/"+sig)
}
return labels
} | go | {
"resource": ""
} |
q176366 | ReadHTTP | test | func ReadHTTP(url string) ([]byte, error) {
var err error
retryDelay := time.Duration(2) * time.Second
for retryCount := 0; retryCount < 5; retryCount++ {
if retryCount > 0 {
time.Sleep(retryDelay)
retryDelay *= time.Duration(2)
}
resp, err := http.Get(url)
if resp != nil && resp.StatusCode >= 500 {
... | go | {
"resource": ""
} |
q176367 | String | test | func (l linesByTimestamp) String() string {
sort.Sort(l)
var log string
for i, line := range l {
switch i {
case len(l) - 1:
log += string(line.actual)
default:
// buf.ReadBytes('\n') does not remove the newline
log += fmt.Sprintf("%s,\n", strings.TrimSuffix(string(line.actual), "\n"))
}
}
retur... | go | {
"resource": ""
} |
q176368 | NewJobSpec | test | func NewJobSpec(spec prowapi.ProwJobSpec, buildID, prowJobID string) JobSpec {
return JobSpec{
Type: spec.Type,
Job: spec.Job,
BuildID: buildID,
ProwJobID: prowJobID,
Refs: spec.Refs,
ExtraRefs: spec.ExtraRefs,
agent: spec.Agent,
}
} | go | {
"resource": ""
} |
q176369 | ResolveSpecFromEnv | test | func ResolveSpecFromEnv() (*JobSpec, error) {
specEnv, ok := os.LookupEnv(JobSpecEnv)
if !ok {
return nil, fmt.Errorf("$%s unset", JobSpecEnv)
}
spec := &JobSpec{}
if err := json.Unmarshal([]byte(specEnv), spec); err != nil {
return nil, fmt.Errorf("malformed $%s: %v", JobSpecEnv, err)
}
return spec, nil
} | go | {
"resource": ""
} |
q176370 | EnvForSpec | test | func EnvForSpec(spec JobSpec) (map[string]string, error) {
env := map[string]string{
jobNameEnv: spec.Job,
buildIDEnv: spec.BuildID,
prowJobIDEnv: spec.ProwJobID,
jobTypeEnv: string(spec.Type),
}
// for backwards compatibility, we provide the build ID
// in both $BUILD_ID and $BUILD_NUMBER for Prow a... | go | {
"resource": ""
} |
q176371 | EnvForType | test | func EnvForType(jobType prowapi.ProwJobType) []string {
baseEnv := []string{jobNameEnv, JobSpecEnv, jobTypeEnv, prowJobIDEnv, buildIDEnv, prowBuildIDEnv}
refsEnv := []string{repoOwnerEnv, repoNameEnv, pullBaseRefEnv, pullBaseShaEnv, pullRefsEnv}
pullEnv := []string{pullNumberEnv, pullPullShaEnv}
switch jobType {
... | go | {
"resource": ""
} |
q176372 | getRevisionFromRef | test | func getRevisionFromRef(refs *prowapi.Refs) string {
if len(refs.Pulls) > 0 {
return refs.Pulls[0].SHA
}
if refs.BaseSHA != "" {
return refs.BaseSHA
}
return refs.BaseRef
} | go | {
"resource": ""
} |
q176373 | GetRevisionFromSpec | test | func GetRevisionFromSpec(spec *JobSpec) string {
if spec.Refs != nil {
return getRevisionFromRef(spec.Refs)
} else if len(spec.ExtraRefs) > 0 {
return getRevisionFromRef(&spec.ExtraRefs[0])
}
return ""
} | go | {
"resource": ""
} |
q176374 | helpProvider | test | func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {
// Only the Description field is specified because this plugin is not triggered with commands and is not configurable.
return &pluginhelp.PluginHelp{
Description: fmt.Sprintf("The merge commit blocker plugin ad... | go | {
"resource": ""
} |
q176375 | load | test | func (g *Group) load(r io.Reader) ([]string, error) {
var repoPaths []string
s := bufio.NewScanner(r)
for s.Scan() {
l := strings.TrimSpace(s.Text())
if l == "" || l[0] == '#' {
// Ignore comments and empty lines.
continue
}
fs := strings.Fields(l)
if len(fs) != 2 {
return repoPaths, &ParseError{... | go | {
"resource": ""
} |
q176376 | loadPaths | test | func (g *Group) loadPaths(r io.Reader) error {
s := bufio.NewScanner(r)
for s.Scan() {
l := strings.TrimSpace(s.Text())
if l == "" || l[0] == '#' {
// Ignore comments and empty lines.
continue
}
g.Paths[l] = true
}
if err := s.Err(); err != nil {
return fmt.Errorf("scan error: %v", err)
}
retu... | go | {
"resource": ""
} |
q176377 | Match | test | func (g *Group) Match(path string) bool {
if g.Paths[path] {
return true
}
for prefix := range g.PathPrefixes {
if strings.HasPrefix(path, prefix) {
return true
}
}
base := filepath.Base(path)
if g.FileNames[base] {
return true
}
for prefix := range g.FilePrefixes {
if strings.HasPrefix(base, p... | go | {
"resource": ""
} |
q176378 | CreateDatabase | test | func (config *InfluxConfig) CreateDatabase(tags map[string]string, measurement string) (*InfluxDB, error) {
client, err := influxdb.NewHTTPClient(influxdb.HTTPConfig{
Addr: config.Host,
Username: config.User,
Password: config.Password,
})
if err != nil {
return nil, err
}
err = dropSeries(client, meas... | go | {
"resource": ""
} |
q176379 | mergeTags | test | func mergeTags(defaultTags, extraTags map[string]string) map[string]string {
newTags := map[string]string{}
for k, v := range defaultTags {
newTags[k] = v
}
for k, v := range extraTags {
newTags[k] = v
}
return newTags
} | go | {
"resource": ""
} |
q176380 | tagsToWhere | test | func tagsToWhere(tags map[string]string) string {
if len(tags) == 0 {
return ""
}
sortedKeys := []string{}
for k := range tags {
sortedKeys = append(sortedKeys, k)
}
sort.Strings(sortedKeys)
conditions := []string{}
for _, key := range sortedKeys {
conditions = append(conditions, fmt.Sprintf(`"%s" = '%v... | go | {
"resource": ""
} |
q176381 | Push | test | func (i *InfluxDB) Push(tags map[string]string, fields map[string]interface{}, date time.Time) error {
pt, err := influxdb.NewPoint(i.measurement, mergeTags(i.tags, tags), fields, date)
if err != nil {
return err
}
i.batch.AddPoint(pt)
i.batchSize++
return nil
} | go | {
"resource": ""
} |
q176382 | artifact | test | func (af *PodLogArtifactFetcher) artifact(jobName, buildID string, sizeLimit int64) (lenses.Artifact, error) {
podLog, err := NewPodLogArtifact(jobName, buildID, sizeLimit, af.jobAgent)
if err != nil {
return nil, fmt.Errorf("Error accessing pod log from given source: %v", err)
}
return podLog, nil
} | go | {
"resource": ""
} |
q176383 | serve | test | func serve() {
http.Handle("/metrics", promhttp.Handler())
logrus.WithError(http.ListenAndServe(":8080", nil)).Fatal("ListenAndServe returned.")
} | go | {
"resource": ""
} |
q176384 | gather | test | func gather(c *plank.Controller) {
tick := time.Tick(30 * time.Second)
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
for {
select {
case <-tick:
start := time.Now()
c.SyncMetrics()
logrus.WithField("metrics-duration", fmt.Sprintf("%v", time.Since(start))).Debug("Metr... | go | {
"resource": ""
} |
q176385 | makeRequest | test | func makeRequest(policy branchprotection.Policy) github.BranchProtectionRequest {
return github.BranchProtectionRequest{
EnforceAdmins: makeAdmins(policy.Admins),
RequiredPullRequestReviews: makeReviews(policy.RequiredPullRequestReviews),
RequiredStatusChecks: makeChecks(policy.RequiredStatusC... | go | {
"resource": ""
} |
q176386 | makeReviews | test | func makeReviews(rp *branchprotection.ReviewPolicy) *github.RequiredPullRequestReviews {
switch {
case rp == nil:
return nil
case rp.Approvals == nil:
logrus.Warn("WARNING: required_pull_request_reviews policy does not specify required_approving_review_count, disabling")
return nil
case *rp.Approvals == 0:
... | go | {
"resource": ""
} |
q176387 | Header | test | func (lens Lens) Header(artifacts []lenses.Artifact, resourceDir string) string {
return executeTemplate(resourceDir, "header", BuildLogsView{})
} | go | {
"resource": ""
} |
q176388 | Callback | test | func (lens Lens) Callback(artifacts []lenses.Artifact, resourceDir string, data string) string {
var request LineRequest
err := json.Unmarshal([]byte(data), &request)
if err != nil {
return "failed to unmarshal request"
}
artifact, ok := artifactByName(artifacts, request.Artifact)
if !ok {
return "no artifact... | go | {
"resource": ""
} |
q176389 | logLinesAll | test | func logLinesAll(artifact lenses.Artifact) ([]string, error) {
read, err := artifact.ReadAll()
if err != nil {
return nil, fmt.Errorf("failed to read log %q: %v", artifact.JobPath(), err)
}
logLines := strings.Split(string(read), "\n")
return logLines, nil
} | go | {
"resource": ""
} |
q176390 | executeTemplate | test | func executeTemplate(resourceDir, templateName string, data interface{}) string {
t := template.New("template.html")
_, err := t.ParseFiles(filepath.Join(resourceDir, "template.html"))
if err != nil {
return fmt.Sprintf("Failed to load template: %v", err)
}
var buf bytes.Buffer
if err := t.ExecuteTemplate(&buf,... | go | {
"resource": ""
} |
q176391 | DeepCopyObject | test | func (in *ResourceObject) DeepCopyObject() runtime.Object {
if c := in.deepCopy(); c != nil {
return c
}
return nil
} | go | {
"resource": ""
} |
q176392 | FromItem | test | func (in *ResourceObject) FromItem(i common.Item) {
r, err := common.ItemToResource(i)
if err == nil {
in.fromResource(r)
}
} | go | {
"resource": ""
} |
q176393 | SetItems | test | func (in *ResourceCollection) SetItems(objects []Object) {
var items []*ResourceObject
for _, b := range objects {
items = append(items, b.(*ResourceObject))
}
in.Items = items
} | go | {
"resource": ""
} |
q176394 | DeepCopyObject | test | func (in *ResourceCollection) DeepCopyObject() runtime.Object {
if c := in.deepCopy(); c != nil {
return c
}
return nil
} | go | {
"resource": ""
} |
q176395 | useContext | test | func useContext(o options, ctx string) error {
_, cmd := command("kubectl", "config", "use-context", ctx)
return cmd.Run()
} | go | {
"resource": ""
} |
q176396 | currentContext | test | func currentContext(o options) (string, error) {
_, cmd := command("kubectl", "config", "current-context")
b, err := cmd.Output()
return strings.TrimSpace(string(b)), err
} | go | {
"resource": ""
} |
q176397 | command | test | func command(bin string, args ...string) ([]string, *exec.Cmd) {
cmd := exec.Command(bin, args...)
cmd.Stderr = os.Stderr
return append([]string{bin}, args...), cmd
} | go | {
"resource": ""
} |
q176398 | describeCluster | test | func describeCluster(o options) (*describe, error) {
if o.account != "" {
act, err := getAccount()
if err != nil {
return nil, fmt.Errorf("get current account: %v", err)
}
defer setAccount(act)
if err = setAccount(o.account); err != nil {
return nil, fmt.Errorf("set account %s: %v", o.account, err)
}... | go | {
"resource": ""
} |
q176399 | Set | test | func (ss *strslice) Set(value string) error {
*ss = append(*ss, value)
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.