_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q175800 | protect | test | func (p *protector) protect() {
bp := p.cfg.BranchProtection
// Scan the branch-protection configuration
for orgName := range bp.Orgs {
org := bp.GetOrg(orgName)
if err := p.UpdateOrg(orgName, *org); err != nil {
p.errors.add(fmt.Errorf("update %s: %v", orgName, err))
}
}
// Do not automatically protect... | go | {
"resource": ""
} |
q175801 | UpdateOrg | test | func (p *protector) UpdateOrg(orgName string, org config.Org) error {
var repos []string
if org.Protect != nil {
// Strongly opinionated org, configure every repo in the org.
rs, err := p.client.GetRepos(orgName, false)
if err != nil {
return fmt.Errorf("list repos: %v", err)
}
for _, r := range rs {
... | go | {
"resource": ""
} |
q175802 | UpdateRepo | test | func (p *protector) UpdateRepo(orgName string, repoName string, repo config.Repo) error {
p.completedRepos[orgName+"/"+repoName] = true
githubRepo, err := p.client.GetRepo(orgName, repoName)
if err != nil {
return fmt.Errorf("could not get repo to check for archival: %v", err)
}
if githubRepo.Archived {
// no... | go | {
"resource": ""
} |
q175803 | UpdateBranch | test | func (p *protector) UpdateBranch(orgName, repo string, branchName string, branch config.Branch, protected bool) error {
bp, err := p.cfg.GetPolicy(orgName, repo, branchName, branch)
if err != nil {
return fmt.Errorf("get policy: %v", err)
}
if bp == nil || bp.Protect == nil {
return nil
}
if !protected && !*b... | go | {
"resource": ""
} |
q175804 | LoadConfig | test | func (o *Options) LoadConfig(config string) error {
return json.Unmarshal([]byte(config), o)
} | go | {
"resource": ""
} |
q175805 | Run | test | func (o *Options) Run() error {
clusterConfig, err := loadClusterConfig()
if err != nil {
return fmt.Errorf("failed to load cluster config: %v", err)
}
client, err := kubernetes.NewForConfig(clusterConfig)
if err != nil {
return err
}
prowJobClient, err := kube.NewClientInCluster(o.ProwJobNamespace)
if er... | go | {
"resource": ""
} |
q175806 | Start | test | func (a *Agent) Start(paths []string) error {
secretsMap, err := LoadSecrets(paths)
if err != nil {
return err
}
a.secretsMap = secretsMap
// Start one goroutine for each file to monitor and update the secret's values.
for secretPath := range secretsMap {
go a.reloadSecret(secretPath)
}
return nil
} | go | {
"resource": ""
} |
q175807 | reloadSecret | test | func (a *Agent) reloadSecret(secretPath string) {
var lastModTime time.Time
logger := logrus.NewEntry(logrus.StandardLogger())
skips := 0
for range time.Tick(1 * time.Second) {
if skips < 600 {
// Check if the file changed to see if it needs to be re-read.
secretStat, err := os.Stat(secretPath)
if err !... | go | {
"resource": ""
} |
q175808 | GetSecret | test | func (a *Agent) GetSecret(secretPath string) []byte {
a.RLock()
defer a.RUnlock()
return a.secretsMap[secretPath]
} | go | {
"resource": ""
} |
q175809 | setSecret | test | func (a *Agent) setSecret(secretPath string, secretValue []byte) {
a.Lock()
defer a.Unlock()
a.secretsMap[secretPath] = secretValue
} | go | {
"resource": ""
} |
q175810 | GetTokenGenerator | test | func (a *Agent) GetTokenGenerator(secretPath string) func() []byte {
return func() []byte {
return a.GetSecret(secretPath)
}
} | go | {
"resource": ""
} |
q175811 | New | test | func New(maxRecordsPerKey int, opener io.Opener, path string) (*History, error) {
hist := &History{
logs: map[string]*recordLog{},
logSizeLimit: maxRecordsPerKey,
opener: opener,
path: path,
}
if path != "" {
// Load existing history from GCS.
var err error
start := time.Now()
... | go | {
"resource": ""
} |
q175812 | Record | test | func (h *History) Record(poolKey, action, baseSHA, err string, targets []prowapi.Pull) {
t := now()
sort.Sort(ByNum(targets))
h.addRecord(
poolKey,
&Record{
Time: t,
Action: action,
BaseSHA: baseSHA,
Target: targets,
Err: err,
},
)
} | go | {
"resource": ""
} |
q175813 | ServeHTTP | test | func (h *History) ServeHTTP(w http.ResponseWriter, r *http.Request) {
b, err := json.Marshal(h.AllRecords())
if err != nil {
logrus.WithError(err).Error("Encoding JSON history.")
b = []byte("{}")
}
if _, err = w.Write(b); err != nil {
logrus.WithError(err).Error("Writing JSON history response.")
}
} | go | {
"resource": ""
} |
q175814 | Flush | test | func (h *History) Flush() {
if h.path == "" {
return
}
records := h.AllRecords()
start := time.Now()
err := writeHistory(h.opener, h.path, records)
log := logrus.WithFields(logrus.Fields{
"duration": time.Since(start).String(),
"path": h.path,
})
if err != nil {
log.WithError(err).Error("Error flush... | go | {
"resource": ""
} |
q175815 | AllRecords | test | func (h *History) AllRecords() map[string][]*Record {
h.Lock()
defer h.Unlock()
res := make(map[string][]*Record, len(h.logs))
for key, log := range h.logs {
res[key] = log.toSlice()
}
return res
} | go | {
"resource": ""
} |
q175816 | MakeCommand | test | func MakeCommand() *cobra.Command {
flags := &flags{}
cmd := &cobra.Command{
Use: "download [bucket] [prowjob]",
Short: "Finds and downloads the coverage profile file from the latest healthy build",
Long: `Finds and downloads the coverage profile file from the latest healthy build
stored in given gcs directo... | go | {
"resource": ""
} |
q175817 | CheckFlags | test | func (c *CommentCounterPlugin) CheckFlags() error {
for _, pattern := range c.pattern {
matcher, err := regexp.Compile(pattern)
if err != nil {
return err
}
c.matcher = append(c.matcher, matcher)
}
return nil
} | go | {
"resource": ""
} |
q175818 | ReceiveComment | test | func (c *CommentCounterPlugin) ReceiveComment(comment sql.Comment) []Point {
points := []Point{}
for _, matcher := range c.matcher {
if matcher.MatchString(comment.Body) {
points = append(points, Point{
Values: map[string]interface{}{
"comment": 1,
},
Date: comment.CommentCreatedAt,
})
}
}... | go | {
"resource": ""
} |
q175819 | NewController | test | func NewController(
pjclientset clientset.Interface,
queue workqueue.RateLimitingInterface,
informer pjinformers.ProwJobInformer,
reporter reportClient,
numWorkers int,
wg *sync.WaitGroup) *Controller {
return &Controller{
pjclientset: pjclientset,
queue: queue,
informer: informer,
reporter: ... | go | {
"resource": ""
} |
q175820 | Run | test | func (c *Controller) Run(stopCh <-chan struct{}) {
// handle a panic with logging and exiting
defer utilruntime.HandleCrash()
// ignore new items in the queue but when all goroutines
// have completed existing items then shutdown
defer c.queue.ShutDown()
logrus.Info("Initiating controller")
c.informer.Informer(... | go | {
"resource": ""
} |
q175821 | runWorker | test | func (c *Controller) runWorker() {
c.wg.Add(1)
for c.processNextItem() {
}
c.wg.Done()
} | go | {
"resource": ""
} |
q175822 | New | test | func New() (*LocalGit, *git.Client, error) {
g, err := exec.LookPath("git")
if err != nil {
return nil, nil, err
}
t, err := ioutil.TempDir("", "localgit")
if err != nil {
return nil, nil, err
}
c, err := git.NewClient()
if err != nil {
os.RemoveAll(t)
return nil, nil, err
}
getSecret := func() []byt... | go | {
"resource": ""
} |
q175823 | MakeFakeRepo | test | func (lg *LocalGit) MakeFakeRepo(org, repo string) error {
rdir := filepath.Join(lg.Dir, org, repo)
if err := os.MkdirAll(rdir, os.ModePerm); err != nil {
return err
}
if err := runCmd(lg.Git, rdir, "init"); err != nil {
return err
}
if err := runCmd(lg.Git, rdir, "config", "user.email", "test@test.test"); e... | go | {
"resource": ""
} |
q175824 | AddCommit | test | func (lg *LocalGit) AddCommit(org, repo string, files map[string][]byte) error {
rdir := filepath.Join(lg.Dir, org, repo)
for f, b := range files {
path := filepath.Join(rdir, f)
if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
return err
}
if err := ioutil.WriteFile(path, b, os.ModePer... | go | {
"resource": ""
} |
q175825 | CheckoutNewBranch | test | func (lg *LocalGit) CheckoutNewBranch(org, repo, branch string) error {
rdir := filepath.Join(lg.Dir, org, repo)
return runCmd(lg.Git, rdir, "checkout", "-b", branch)
} | go | {
"resource": ""
} |
q175826 | Checkout | test | func (lg *LocalGit) Checkout(org, repo, commitlike string) error {
rdir := filepath.Join(lg.Dir, org, repo)
return runCmd(lg.Git, rdir, "checkout", commitlike)
} | go | {
"resource": ""
} |
q175827 | RevParse | test | func (lg *LocalGit) RevParse(org, repo, commitlike string) (string, error) {
rdir := filepath.Join(lg.Dir, org, repo)
return runCmdOutput(lg.Git, rdir, "rev-parse", commitlike)
} | go | {
"resource": ""
} |
q175828 | CleanAll | test | func CleanAll(sess *session.Session, region string) error {
acct, err := account.GetAccount(sess, regions.Default)
if err != nil {
return errors.Wrap(err, "Failed to retrieve account")
}
klog.V(1).Infof("Account: %s", acct)
var regionList []string
if region == "" {
regionList, err = regions.GetAll(sess)
if... | go | {
"resource": ""
} |
q175829 | optionsForRepo | test | func optionsForRepo(config *plugins.Configuration, org, repo string) *plugins.Lgtm {
fullName := fmt.Sprintf("%s/%s", org, repo)
for i := range config.Lgtm {
if !strInSlice(org, config.Lgtm[i].Repos) && !strInSlice(fullName, config.Lgtm[i].Repos) {
continue
}
return &config.Lgtm[i]
}
return &plugins.Lgtm{}... | go | {
"resource": ""
} |
q175830 | getChangedFiles | test | func getChangedFiles(gc githubClient, org, repo string, number int) ([]string, error) {
changes, err := gc.GetPullRequestChanges(org, repo, number)
if err != nil {
return nil, fmt.Errorf("cannot get PR changes for %s/%s#%d", org, repo, number)
}
var filenames []string
for _, change := range changes {
filenames... | go | {
"resource": ""
} |
q175831 | loadReviewers | test | func loadReviewers(ro repoowners.RepoOwner, filenames []string) sets.String {
reviewers := sets.String{}
for _, filename := range filenames {
reviewers = reviewers.Union(ro.Approvers(filename)).Union(ro.Reviewers(filename))
}
return reviewers
} | go | {
"resource": ""
} |
q175832 | NewController | test | func NewController(lastSyncFallback, cookiefilePath string, projects map[string][]string, kc *kube.Client, cfg config.Getter) (*Controller, error) {
if lastSyncFallback == "" {
return nil, errors.New("empty lastSyncFallback")
}
var lastUpdate time.Time
if buf, err := ioutil.ReadFile(lastSyncFallback); err == nil... | go | {
"resource": ""
} |
q175833 | SaveLastSync | test | func (c *Controller) SaveLastSync(lastSync time.Time) error {
if c.lastSyncFallback == "" {
return nil
}
lastSyncUnix := strconv.FormatInt(lastSync.Unix(), 10)
logrus.Infof("Writing last sync: %s", lastSyncUnix)
tempFile, err := ioutil.TempFile(filepath.Dir(c.lastSyncFallback), "temp")
if err != nil {
retur... | go | {
"resource": ""
} |
q175834 | Sync | test | func (c *Controller) Sync() error {
syncTime := c.lastUpdate
for instance, changes := range c.gc.QueryChanges(c.lastUpdate, c.config().Gerrit.RateLimit) {
for _, change := range changes {
if err := c.ProcessChange(instance, change); err != nil {
logrus.WithError(err).Errorf("Failed process change %v", chang... | go | {
"resource": ""
} |
q175835 | AddFlags | test | func (e *EventCounterPlugin) AddFlags(cmd *cobra.Command) {
cmd.Flags().StringVar(&e.desc, "event", "", "Match event (eg: `opened`)")
} | go | {
"resource": ""
} |
q175836 | CheckFlags | test | func (e *EventCounterPlugin) CheckFlags() error {
e.matcher = NewEventMatcher(e.desc)
return nil
} | go | {
"resource": ""
} |
q175837 | ReceiveIssueEvent | test | func (e *EventCounterPlugin) ReceiveIssueEvent(event sql.IssueEvent) []Point {
var label string
if event.Label != nil {
label = *event.Label
}
if !e.matcher.Match(event.Event, label) {
return nil
}
return []Point{
{
Values: map[string]interface{}{"event": 1},
Date: event.EventCreatedAt,
},
}
} | go | {
"resource": ""
} |
q175838 | Upload | test | func Upload(bucket *storage.BucketHandle, uploadTargets map[string]UploadFunc) error {
errCh := make(chan error, len(uploadTargets))
group := &sync.WaitGroup{}
group.Add(len(uploadTargets))
for dest, upload := range uploadTargets {
obj := bucket.Object(dest)
logrus.WithField("dest", dest).Info("Queued for uploa... | go | {
"resource": ""
} |
q175839 | FileUploadWithMetadata | test | func FileUploadWithMetadata(file string, metadata map[string]string) UploadFunc {
return func(obj *storage.ObjectHandle) error {
reader, err := os.Open(file)
if err != nil {
return err
}
uploadErr := DataUploadWithMetadata(reader, metadata)(obj)
closeErr := reader.Close()
return errorutil.NewAggregate... | go | {
"resource": ""
} |
q175840 | DataUploadWithMetadata | test | func DataUploadWithMetadata(src io.Reader, metadata map[string]string) UploadFunc {
return func(obj *storage.ObjectHandle) error {
writer := obj.NewWriter(context.Background())
writer.Metadata = metadata
_, copyErr := io.Copy(writer, src)
closeErr := writer.Close()
return errorutil.NewAggregate(copyErr, clo... | go | {
"resource": ""
} |
q175841 | HasLabel | test | func HasLabel(label string, issueLabels []Label) bool {
for _, l := range issueLabels {
if strings.ToLower(l.Name) == strings.ToLower(label) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q175842 | ImageTooBig | test | func ImageTooBig(url string) (bool, error) {
// limit is 10MB
limit := 10000000
// try to get the image size from Content-Length header
resp, err := http.Head(url)
if err != nil {
return true, fmt.Errorf("HEAD error: %v", err)
}
if sc := resp.StatusCode; sc != http.StatusOK {
return true, fmt.Errorf("failing... | go | {
"resource": ""
} |
q175843 | LevelFromPermissions | test | func LevelFromPermissions(permissions RepoPermissions) RepoPermissionLevel {
if permissions.Admin {
return Admin
} else if permissions.Push {
return Write
} else if permissions.Pull {
return Read
} else {
return None
}
} | go | {
"resource": ""
} |
q175844 | PermissionsFromLevel | test | func PermissionsFromLevel(permission RepoPermissionLevel) RepoPermissions {
switch permission {
case None:
return RepoPermissions{}
case Read:
return RepoPermissions{Pull: true}
case Write:
return RepoPermissions{Pull: true, Push: true}
case Admin:
return RepoPermissions{Pull: true, Push: true, Admin: true... | go | {
"resource": ""
} |
q175845 | newProwJobs | test | func newProwJobs(c *ProwV1Client, namespace string) *prowJobs {
return &prowJobs{
client: c.RESTClient(),
ns: namespace,
}
} | go | {
"resource": ""
} |
q175846 | GetApplicable | test | func (b Blockers) GetApplicable(org, repo, branch string) []Blocker {
var res []Blocker
res = append(res, b.Repo[orgRepo{org: org, repo: repo}]...)
res = append(res, b.Branch[orgRepoBranch{org: org, repo: repo, branch: branch}]...)
sort.Slice(res, func(i, j int) bool {
return res[i].Number < res[j].Number
})
r... | go | {
"resource": ""
} |
q175847 | serve | test | func serve(jc *jenkins.Client) {
http.Handle("/", gziphandler.GzipHandler(handleLog(jc)))
http.Handle("/metrics", promhttp.Handler())
logrus.WithError(http.ListenAndServe(":8080", nil)).Fatal("ListenAndServe returned.")
} | go | {
"resource": ""
} |
q175848 | NewCountPlugin | test | func NewCountPlugin(runner func(Plugin) error) *cobra.Command {
stateCounter := &StatePlugin{}
eventCounter := &EventCounterPlugin{}
commentsAsEvents := NewFakeCommentPluginWrapper(eventCounter)
commentCounter := &CommentCounterPlugin{}
authorLoggable := NewMultiplexerPluginWrapper(
commentsAsEvents,
commentCo... | go | {
"resource": ""
} |
q175849 | ReceiveComment | test | func (o *FakeCommentPluginWrapper) ReceiveComment(comment sql.Comment) []Point {
// Create a fake "commented" event for every comment we receive.
fakeEvent := sql.IssueEvent{
IssueID: comment.IssueID,
Event: "commented",
EventCreatedAt: comment.CommentCreatedAt,
Actor: &comment.User,
... | go | {
"resource": ""
} |
q175850 | updateMetrics | test | func updateMetrics(interval time.Duration, diskRoot string) {
logger := logrus.WithField("sync-loop", "updateMetrics")
ticker := time.NewTicker(interval)
for ; true; <-ticker.C {
logger.Info("tick")
_, bytesFree, bytesUsed, err := diskutil.GetDiskUsage(diskRoot)
if err != nil {
logger.WithError(err).Error("... | go | {
"resource": ""
} |
q175851 | LogStatus | test | func (r *Ranch) LogStatus() {
resources, err := r.Storage.GetResources()
if err != nil {
return
}
resJSON, err := json.Marshal(resources)
if err != nil {
logrus.WithError(err).Errorf("Fail to marshal Resources. %v", resources)
}
logrus.Infof("Current Resources : %v", string(resJSON))
} | go | {
"resource": ""
} |
q175852 | SyncConfig | test | func (r *Ranch) SyncConfig(config string) error {
resources, err := ParseConfig(config)
if err != nil {
return err
}
if err := r.Storage.SyncResources(resources); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q175853 | Metric | test | func (r *Ranch) Metric(rtype string) (common.Metric, error) {
metric := common.Metric{
Type: rtype,
Current: map[string]int{},
Owners: map[string]int{},
}
resources, err := r.Storage.GetResources()
if err != nil {
logrus.WithError(err).Error("cannot find resources")
return metric, &ResourceNotFound{r... | go | {
"resource": ""
} |
q175854 | FormatURL | test | func FormatURL(dogURL string) (string, error) {
if dogURL == "" {
return "", errors.New("empty url")
}
src, err := url.ParseRequestURI(dogURL)
if err != nil {
return "", fmt.Errorf("invalid url %s: %v", dogURL, err)
}
return fmt.Sprintf("[](%s)", src, src), nil
} | go | {
"resource": ""
} |
q175855 | runAndSkipJobs | test | func runAndSkipJobs(c Client, pr *github.PullRequest, requestedJobs []config.Presubmit, skippedJobs []config.Presubmit, eventGUID string, elideSkippedContexts bool) error {
if err := validateContextOverlap(requestedJobs, skippedJobs); err != nil {
c.Logger.WithError(err).Warn("Could not run or skip requested jobs, o... | go | {
"resource": ""
} |
q175856 | validateContextOverlap | test | func validateContextOverlap(toRun, toSkip []config.Presubmit) error {
requestedContexts := sets.NewString()
for _, job := range toRun {
requestedContexts.Insert(job.Context)
}
skippedContexts := sets.NewString()
for _, job := range toSkip {
skippedContexts.Insert(job.Context)
}
if overlap := requestedContext... | go | {
"resource": ""
} |
q175857 | RunRequested | test | func RunRequested(c Client, pr *github.PullRequest, requestedJobs []config.Presubmit, eventGUID string) error {
baseSHA, err := c.GitHubClient.GetRef(pr.Base.Repo.Owner.Login, pr.Base.Repo.Name, "heads/"+pr.Base.Ref)
if err != nil {
return err
}
var errors []error
for _, job := range requestedJobs {
c.Logger.... | go | {
"resource": ""
} |
q175858 | skipRequested | test | func skipRequested(c Client, pr *github.PullRequest, skippedJobs []config.Presubmit) error {
var errors []error
for _, job := range skippedJobs {
if job.SkipReport {
continue
}
c.Logger.Infof("Skipping %s build.", job.Name)
if err := c.GitHubClient.CreateStatus(pr.Base.Repo.Owner.Login, pr.Base.Repo.Name, ... | go | {
"resource": ""
} |
q175859 | Match | test | func (l LabelEvent) Match(eventName, label string) bool {
return eventName == "labeled" && label == l.Label
} | go | {
"resource": ""
} |
q175860 | Match | test | func (u UnlabelEvent) Match(eventName, label string) bool {
return eventName == "unlabeled" && label == u.Label
} | go | {
"resource": ""
} |
q175861 | AddFlags | test | func (o *GitHubOptions) AddFlags(fs *flag.FlagSet) {
o.addFlags(true, fs)
} | go | {
"resource": ""
} |
q175862 | AddFlagsWithoutDefaultGitHubTokenPath | test | func (o *GitHubOptions) AddFlagsWithoutDefaultGitHubTokenPath(fs *flag.FlagSet) {
o.addFlags(false, fs)
} | go | {
"resource": ""
} |
q175863 | Validate | test | func (o *GitHubOptions) Validate(dryRun bool) error {
for _, uri := range o.endpoint.Strings() {
if uri == "" {
uri = github.DefaultAPIEndpoint
} else if _, err := url.ParseRequestURI(uri); err != nil {
return fmt.Errorf("invalid -github-endpoint URI: %q", uri)
}
}
if o.graphqlEndpoint == "" {
o.graph... | go | {
"resource": ""
} |
q175864 | GitHubClientWithLogFields | test | func (o *GitHubOptions) GitHubClientWithLogFields(secretAgent *secret.Agent, dryRun bool, fields logrus.Fields) (client *github.Client, err error) {
var generator *func() []byte
if o.TokenPath == "" {
generatorFunc := func() []byte {
return []byte{}
}
generator = &generatorFunc
} else {
if secretAgent == ... | go | {
"resource": ""
} |
q175865 | GitHubClient | test | func (o *GitHubOptions) GitHubClient(secretAgent *secret.Agent, dryRun bool) (client *github.Client, err error) {
return o.GitHubClientWithLogFields(secretAgent, dryRun, logrus.Fields{})
} | go | {
"resource": ""
} |
q175866 | GitClient | test | func (o *GitHubOptions) GitClient(secretAgent *secret.Agent, dryRun bool) (client *git.Client, err error) {
client, err = git.NewClient()
if err != nil {
return nil, err
}
// We must capture the value of client here to prevent issues related
// to the use of named return values when an error is encountered.
//... | go | {
"resource": ""
} |
q175867 | toMap | test | func toMap(g *calculation.CoverageList) map[string]calculation.Coverage {
m := make(map[string]calculation.Coverage)
for _, cov := range g.Group {
m[cov.Name] = cov
}
return m
} | go | {
"resource": ""
} |
q175868 | findChanges | test | func findChanges(baseList *calculation.CoverageList, newList *calculation.CoverageList) []*coverageChange {
var changes []*coverageChange
baseFilesMap := toMap(baseList)
for _, newCov := range newList.Group {
baseCov, ok := baseFilesMap[newCov.Name]
var baseRatio float32
if !ok {
baseRatio = -1
} else {
... | go | {
"resource": ""
} |
q175869 | CreateDatabase | test | func (config *MySQLConfig) CreateDatabase() (*gorm.DB, error) {
db, err := gorm.Open("mysql", config.getDSN(""))
if err != nil {
return nil, err
}
db.Exec(fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %v;", config.Db))
db.Close()
db, err = gorm.Open("mysql", config.getDSN(config.Db))
err = db.AutoMigrate(&Assig... | go | {
"resource": ""
} |
q175870 | ShouldReport | test | func (c *Client) ShouldReport(pj *v1.ProwJob) bool {
if !pj.Spec.Report {
// Respect report field
return false
}
if pj.Spec.Type != v1.PresubmitJob && pj.Spec.Type != v1.PostsubmitJob {
// Report presubmit and postsubmit github jobs for github reporter
return false
}
if c.reportAgent != "" && pj.Spec.Ag... | go | {
"resource": ""
} |
q175871 | Report | test | func (c *Client) Report(pj *v1.ProwJob) ([]*v1.ProwJob, error) {
// TODO(krzyzacy): ditch ReportTemplate, and we can drop reference to config.Getter
return []*v1.ProwJob{pj}, report.Report(c.gc, c.config().Plank.ReportTemplate, *pj, c.config().GitHubReporter.JobTypesToReport)
} | go | {
"resource": ""
} |
q175872 | MarkComplete | test | func (s *Set) MarkComplete() int {
var gone []string
for key := range s.firstSeen {
if !s.marked[key] {
gone = append(gone, key)
}
}
for _, key := range gone {
klog.V(1).Infof("%s: deleted since last run", key)
delete(s.firstSeen, key)
}
if len(s.swept) > 0 {
klog.Errorf("%d resources swept: %v", l... | go | {
"resource": ""
} |
q175873 | NewJobAgent | test | func NewJobAgent(kc serviceClusterClient, plClients map[string]PodLogClient, cfg config.Getter) *JobAgent {
return &JobAgent{
kc: kc,
pkcs: plClients,
config: cfg,
}
} | go | {
"resource": ""
} |
q175874 | Start | test | func (ja *JobAgent) Start() {
ja.tryUpdate()
go func() {
t := time.Tick(period)
for range t {
ja.tryUpdate()
}
}()
} | go | {
"resource": ""
} |
q175875 | Jobs | test | func (ja *JobAgent) Jobs() []Job {
ja.mut.Lock()
defer ja.mut.Unlock()
res := make([]Job, len(ja.jobs))
copy(res, ja.jobs)
return res
} | go | {
"resource": ""
} |
q175876 | ProwJobs | test | func (ja *JobAgent) ProwJobs() []prowapi.ProwJob {
ja.mut.Lock()
defer ja.mut.Unlock()
res := make([]prowapi.ProwJob, len(ja.prowJobs))
copy(res, ja.prowJobs)
return res
} | go | {
"resource": ""
} |
q175877 | GetProwJob | test | func (ja *JobAgent) GetProwJob(job, id string) (prowapi.ProwJob, error) {
if ja == nil {
return prowapi.ProwJob{}, fmt.Errorf("Prow job agent doesn't exist (are you running locally?)")
}
var j prowapi.ProwJob
ja.mut.Lock()
idMap, ok := ja.jobsIDMap[job]
if ok {
j, ok = idMap[id]
}
ja.mut.Unlock()
if !ok {
... | go | {
"resource": ""
} |
q175878 | GetJobLog | test | func (ja *JobAgent) GetJobLog(job, id string) ([]byte, error) {
j, err := ja.GetProwJob(job, id)
if err != nil {
return nil, fmt.Errorf("error getting prowjob: %v", err)
}
if j.Spec.Agent == prowapi.KubernetesAgent {
client, ok := ja.pkcs[j.ClusterAlias()]
if !ok {
return nil, fmt.Errorf("cannot get logs f... | go | {
"resource": ""
} |
q175879 | unionStrings | test | func unionStrings(parent, child []string) []string {
if child == nil {
return parent
}
if parent == nil {
return child
}
s := sets.NewString(parent...)
s.Insert(child...)
return s.List()
} | go | {
"resource": ""
} |
q175880 | Apply | test | func (p Policy) Apply(child Policy) Policy {
return Policy{
Protect: selectBool(p.Protect, child.Protect),
RequiredStatusChecks: mergeContextPolicy(p.RequiredStatusChecks, child.RequiredStatusChecks),
Admins: selectBool(p.Admins, child.Admins),
Restrictions: ... | go | {
"resource": ""
} |
q175881 | GetOrg | test | func (bp BranchProtection) GetOrg(name string) *Org {
o, ok := bp.Orgs[name]
if ok {
o.Policy = bp.Apply(o.Policy)
} else {
o.Policy = bp.Policy
}
return &o
} | go | {
"resource": ""
} |
q175882 | GetRepo | test | func (o Org) GetRepo(name string) *Repo {
r, ok := o.Repos[name]
if ok {
r.Policy = o.Apply(r.Policy)
} else {
r.Policy = o.Policy
}
return &r
} | go | {
"resource": ""
} |
q175883 | GetBranch | test | func (r Repo) GetBranch(name string) (*Branch, error) {
b, ok := r.Branches[name]
if ok {
b.Policy = r.Apply(b.Policy)
if b.Protect == nil {
return nil, errors.New("defined branch policies must set protect")
}
} else {
b.Policy = r.Policy
}
return &b, nil
} | go | {
"resource": ""
} |
q175884 | GetPolicy | test | func (c *Config) GetPolicy(org, repo, branch string, b Branch) (*Policy, error) {
policy := b.Policy
// Automatically require contexts from prow which must always be present
if prowContexts, _, _ := BranchRequirements(org, repo, branch, c.Presubmits); len(prowContexts) > 0 {
// Error if protection is disabled
i... | go | {
"resource": ""
} |
q175885 | UpdateIssueEvents | test | func UpdateIssueEvents(issueID int, db *gorm.DB, client ClientInterface) {
latest, err := findLatestEvent(issueID, db, client.RepositoryName())
if err != nil {
glog.Error("Failed to find last event: ", err)
return
}
c := make(chan *github.IssueEvent, 500)
go client.FetchIssueEvents(issueID, latest, c)
for ev... | go | {
"resource": ""
} |
q175886 | enqueueKey | test | func (c *controller) enqueueKey(ctx string, obj interface{}) {
switch o := obj.(type) {
case *prowjobv1.ProwJob:
c.workqueue.AddRateLimited(toKey(ctx, o.Spec.Namespace, o.Name))
case *buildv1alpha1.Build:
c.workqueue.AddRateLimited(toKey(ctx, o.Namespace, o.Name))
default:
logrus.Warnf("cannot enqueue unknown... | go | {
"resource": ""
} |
q175887 | prowJobStatus | test | func prowJobStatus(bs buildv1alpha1.BuildStatus) (prowjobv1.ProwJobState, string) {
started := bs.StartTime
finished := bs.CompletionTime
pcond := bs.GetCondition(buildv1alpha1.BuildSucceeded)
if pcond == nil {
if !finished.IsZero() {
return prowjobv1.ErrorState, descMissingCondition
}
return prowjobv1.Tri... | go | {
"resource": ""
} |
q175888 | buildEnv | test | func buildEnv(pj prowjobv1.ProwJob, buildID string) (map[string]string, error) {
return downwardapi.EnvForSpec(downwardapi.NewJobSpec(pj.Spec, buildID, pj.Name))
} | go | {
"resource": ""
} |
q175889 | defaultArguments | test | func defaultArguments(t *buildv1alpha1.TemplateInstantiationSpec, rawEnv map[string]string) {
keys := sets.String{}
for _, arg := range t.Arguments {
keys.Insert(arg.Name)
}
for _, k := range sets.StringKeySet(rawEnv).List() { // deterministic ordering
if keys.Has(k) {
continue
}
t.Arguments = append(t.A... | go | {
"resource": ""
} |
q175890 | defaultEnv | test | func defaultEnv(c *coreapi.Container, rawEnv map[string]string) {
keys := sets.String{}
for _, arg := range c.Env {
keys.Insert(arg.Name)
}
for _, k := range sets.StringKeySet(rawEnv).List() { // deterministic ordering
if keys.Has(k) {
continue
}
c.Env = append(c.Env, coreapi.EnvVar{Name: k, Value: rawEn... | go | {
"resource": ""
} |
q175891 | injectSource | test | func injectSource(b *buildv1alpha1.Build, pj prowjobv1.ProwJob) (bool, error) {
if b.Spec.Source != nil {
return false, nil
}
srcContainer, refs, cloneVolumes, err := decorate.CloneRefs(pj, codeMount, logMount)
if err != nil {
return false, fmt.Errorf("clone source error: %v", err)
}
if srcContainer == nil {
... | go | {
"resource": ""
} |
q175892 | injectedSteps | test | func injectedSteps(encodedJobSpec string, dc prowjobv1.DecorationConfig, injectedSource bool, toolsMount coreapi.VolumeMount, entries []wrapper.Options) ([]coreapi.Container, *coreapi.Container, *coreapi.Volume, error) {
gcsVol, gcsMount, gcsOptions := decorate.GCSOptions(dc)
sidecar, err := decorate.Sidecar(dc.Util... | go | {
"resource": ""
} |
q175893 | determineTimeout | test | func determineTimeout(spec *buildv1alpha1.BuildSpec, dc *prowjobv1.DecorationConfig, defaultTimeout time.Duration) time.Duration {
switch {
case spec.Timeout != nil:
return spec.Timeout.Duration
case dc != nil && dc.Timeout.Duration > 0:
return dc.Timeout.Duration
default:
return defaultTimeout
}
} | go | {
"resource": ""
} |
q175894 | makeBuild | test | func makeBuild(pj prowjobv1.ProwJob, defaultTimeout time.Duration) (*buildv1alpha1.Build, error) {
if pj.Spec.BuildSpec == nil {
return nil, errors.New("nil BuildSpec in spec")
}
buildID := pj.Status.BuildID
if buildID == "" {
return nil, errors.New("empty BuildID in status")
}
b := buildv1alpha1.Build{
Obj... | go | {
"resource": ""
} |
q175895 | newLabels | test | func newLabels(issueID int, gLabels []github.Label, repository string) ([]sql.Label, error) {
labels := []sql.Label{}
repository = strings.ToLower(repository)
for _, label := range gLabels {
if label.Name == nil {
return nil, fmt.Errorf("Label is missing name field")
}
labels = append(labels, sql.Label{
... | go | {
"resource": ""
} |
q175896 | newAssignees | test | func newAssignees(issueID int, gAssignees []*github.User, repository string) ([]sql.Assignee, error) {
assignees := []sql.Assignee{}
repository = strings.ToLower(repository)
for _, assignee := range gAssignees {
if assignee != nil && assignee.Login == nil {
return nil, fmt.Errorf("Assignee is missing Login fie... | go | {
"resource": ""
} |
q175897 | NewIssueComment | test | func NewIssueComment(issueID int, gComment *github.IssueComment, repository string) (*sql.Comment, error) {
if gComment.ID == nil ||
gComment.Body == nil ||
gComment.CreatedAt == nil ||
gComment.UpdatedAt == nil {
return nil, fmt.Errorf("IssueComment is missing mandatory field: %s", gComment)
}
var login st... | go | {
"resource": ""
} |
q175898 | messageFilter | test | func messageFilter(lastUpdate time.Time, change client.ChangeInfo, presubmits []config.Presubmit) (pjutil.Filter, error) {
var filters []pjutil.Filter
currentRevision := change.Revisions[change.CurrentRevision].Number
for _, message := range change.Messages {
messageTime := message.Date.Time
if message.RevisionN... | go | {
"resource": ""
} |
q175899 | IsSuccess | test | func (jb *Build) IsSuccess() bool {
return jb.Result != nil && *jb.Result == success
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.