_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q175900 | IsFailure | test | func (jb *Build) IsFailure() bool {
return jb.Result != nil && (*jb.Result == failure || *jb.Result == unstable)
} | go | {
"resource": ""
} |
q175901 | IsAborted | test | func (jb *Build) IsAborted() bool {
return jb.Result != nil && *jb.Result == aborted
} | go | {
"resource": ""
} |
q175902 | ProwJobID | test | func (jb *Build) ProwJobID() string {
for _, action := range jb.Actions {
for _, p := range action.Parameters {
if p.Name == prowJobID {
value, ok := p.Value.(string)
if !ok {
logrus.Errorf("Cannot determine %s value for %#v", p.Name, jb)
continue
}
return value
}
}
}
return ""
} | go | {
"resource": ""
} |
q175903 | BuildID | test | func (jb *Build) BuildID() string {
var buildID string
hasProwJobID := false
for _, action := range jb.Actions {
for _, p := range action.Parameters {
hasProwJobID = hasProwJobID || p.Name == prowJobID
if p.Name == statusBuildID {
value, ok := p.Value.(string)
if !ok {
logrus.Errorf("Cannot dete... | go | {
"resource": ""
} |
q175904 | CrumbRequest | test | func (c *Client) CrumbRequest() error {
if c.authConfig.csrfToken != "" && c.authConfig.csrfRequestField != "" {
return nil
}
c.logger.Debug("CrumbRequest")
data, err := c.GetSkipMetrics("/crumbIssuer/api/json")
if err != nil {
return err
}
crumbResp := struct {
Crumb string `json:"crumb"`
Cr... | go | {
"resource": ""
} |
q175905 | measure | test | func (c *Client) measure(method, path string, code int, start time.Time) {
if c.metrics == nil {
return
}
c.metrics.RequestLatency.WithLabelValues(method, path).Observe(time.Since(start).Seconds())
c.metrics.Requests.WithLabelValues(method, path, fmt.Sprintf("%d", code)).Inc()
} | go | {
"resource": ""
} |
q175906 | GetSkipMetrics | test | func (c *Client) GetSkipMetrics(path string) ([]byte, error) {
resp, err := c.request(http.MethodGet, path, nil, false)
if err != nil {
return nil, err
}
return readResp(resp)
} | go | {
"resource": ""
} |
q175907 | Get | test | func (c *Client) Get(path string) ([]byte, error) {
resp, err := c.request(http.MethodGet, path, nil, true)
if err != nil {
return nil, err
}
return readResp(resp)
} | go | {
"resource": ""
} |
q175908 | request | test | func (c *Client) request(method, path string, params url.Values, measure bool) (*http.Response, error) {
var resp *http.Response
var err error
backoff := retryDelay
urlPath := fmt.Sprintf("%s%s", c.baseURL, path)
if params != nil {
urlPath = fmt.Sprintf("%s?%s", urlPath, params.Encode())
}
start := time.Now(... | go | {
"resource": ""
} |
q175909 | doRequest | test | func (c *Client) doRequest(method, path string) (*http.Response, error) {
req, err := http.NewRequest(method, path, nil)
if err != nil {
return nil, err
}
if c.authConfig != nil {
if c.authConfig.Basic != nil {
req.SetBasicAuth(c.authConfig.Basic.User, string(c.authConfig.Basic.GetToken()))
}
if c.authCo... | go | {
"resource": ""
} |
q175910 | getJobName | test | func getJobName(spec *prowapi.ProwJobSpec) string {
if spec.JenkinsSpec != nil && spec.JenkinsSpec.GitHubBranchSourceJob && spec.Refs != nil {
if len(spec.Refs.Pulls) > 0 {
return fmt.Sprintf("%s/view/change-requests/job/PR-%d", spec.Job, spec.Refs.Pulls[0].Number)
}
return fmt.Sprintf("%s/job/%s", spec.Job,... | go | {
"resource": ""
} |
q175911 | getBuildPath | test | func getBuildPath(spec *prowapi.ProwJobSpec) string {
jenkinsJobName := getJobName(spec)
jenkinsPath := fmt.Sprintf("/job/%s/build", jenkinsJobName)
return jenkinsPath
} | go | {
"resource": ""
} |
q175912 | GetJobInfo | test | func (c *Client) GetJobInfo(spec *prowapi.ProwJobSpec) (*JobInfo, error) {
path := getJobInfoPath(spec)
c.logger.Debugf("getJobInfoPath: %s", path)
data, err := c.Get(path)
if err != nil {
c.logger.Errorf("Failed to get job info: %v", err)
return nil, err
}
var jobInfo JobInfo
if err := json.Unmarshal(da... | go | {
"resource": ""
} |
q175913 | JobParameterized | test | func (c *Client) JobParameterized(jobInfo *JobInfo) bool {
for _, prop := range jobInfo.Property {
if prop.ParameterDefinitions != nil && len(prop.ParameterDefinitions) > 0 {
return true
}
}
return false
} | go | {
"resource": ""
} |
q175914 | EnsureBuildableJob | test | func (c *Client) EnsureBuildableJob(spec *prowapi.ProwJobSpec) error {
var jobInfo *JobInfo
// wait at most 20 seconds for the job to appear
getJobInfoBackoff := wait.Backoff{
Duration: time.Duration(10) * time.Second,
Factor: 1,
Jitter: 0,
Steps: 2,
}
getJobErr := wait.ExponentialBackoff(getJobIn... | go | {
"resource": ""
} |
q175915 | LaunchBuild | test | func (c *Client) LaunchBuild(spec *prowapi.ProwJobSpec, params url.Values) error {
var path string
if params != nil {
path = getBuildWithParametersPath(spec)
} else {
path = getBuildPath(spec)
}
c.logger.Debugf("getBuildPath/getBuildWithParametersPath: %s", path)
resp, err := c.request(http.MethodPost, pat... | go | {
"resource": ""
} |
q175916 | Build | test | func (c *Client) Build(pj *prowapi.ProwJob, buildID string) error {
c.logger.WithFields(pjutil.ProwJobFields(pj)).Info("Build")
return c.BuildFromSpec(&pj.Spec, buildID, pj.ObjectMeta.Name)
} | go | {
"resource": ""
} |
q175917 | BuildFromSpec | test | func (c *Client) BuildFromSpec(spec *prowapi.ProwJobSpec, buildID, prowJobID string) error {
if c.dryRun {
return nil
}
env, err := downwardapi.EnvForSpec(downwardapi.NewJobSpec(*spec, buildID, prowJobID))
if err != nil {
return err
}
params := url.Values{}
for key, value := range env {
params.Set(key, val... | go | {
"resource": ""
} |
q175918 | GetEnqueuedBuilds | test | func (c *Client) GetEnqueuedBuilds(jobs []BuildQueryParams) (map[string]Build, error) {
c.logger.Debug("GetEnqueuedBuilds")
data, err := c.Get("/queue/api/json?tree=items[task[name],actions[parameters[name,value]]]")
if err != nil {
return nil, fmt.Errorf("cannot list builds from the queue: %v", err)
}
page := ... | go | {
"resource": ""
} |
q175919 | Abort | test | func (c *Client) Abort(job string, build *Build) error {
c.logger.Debugf("Abort(%v %v)", job, build.Number)
if c.dryRun {
return nil
}
resp, err := c.request(http.MethodPost, fmt.Sprintf("/job/%s/%d/stop", job, build.Number), nil, false)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCod... | go | {
"resource": ""
} |
q175920 | PresubmitToJobSpec | test | func PresubmitToJobSpec(pre config.Presubmit) *downwardapi.JobSpec {
return &downwardapi.JobSpec{
Type: prowapi.PresubmitJob,
Job: pre.Name,
}
} | go | {
"resource": ""
} |
q175921 | PostsubmitToJobSpec | test | func PostsubmitToJobSpec(post config.Postsubmit) *downwardapi.JobSpec {
return &downwardapi.JobSpec{
Type: prowapi.PostsubmitJob,
Job: post.Name,
}
} | go | {
"resource": ""
} |
q175922 | PeriodicToJobSpec | test | func PeriodicToJobSpec(periodic config.Periodic) *downwardapi.JobSpec {
return &downwardapi.JobSpec{
Type: prowapi.PeriodicJob,
Job: periodic.Name,
}
} | go | {
"resource": ""
} |
q175923 | GetBuildID | test | func GetBuildID(name, totURL string) (string, error) {
if totURL == "" {
return node.Generate().String(), nil
}
var err error
url, err := url.Parse(totURL)
if err != nil {
return "", fmt.Errorf("invalid tot url: %v", err)
}
url.Path = path.Join(url.Path, "vend", name)
sleepDuration := 100 * time.Millisecond... | go | {
"resource": ""
} |
q175924 | listGcsObjects | test | func listGcsObjects(ctx context.Context, client *storage.Client, bucketName, prefix, delim string) (
[]string, error) {
var objects []string
it := client.Bucket(bucketName).Objects(ctx, &storage.Query{
Prefix: prefix,
Delimiter: delim,
})
for {
attrs, err := it.Next()
if err == iterator.Done {
brea... | go | {
"resource": ""
} |
q175925 | FindBaseProfile | test | func FindBaseProfile(ctx context.Context, client *storage.Client, bucket, prowJobName, artifactsDirName,
covProfileName string) ([]byte, error) {
dirOfJob := path.Join("logs", prowJobName)
strBuilds, err := listGcsObjects(ctx, client, bucket, dirOfJob+"/", "/")
if err != nil {
return nil, fmt.Errorf("error list... | go | {
"resource": ""
} |
q175926 | sortBuilds | test | func sortBuilds(strBuilds []string) []int {
var res []int
for _, buildStr := range strBuilds {
num, err := strconv.Atoi(buildStr)
if err != nil {
logrus.Infof("Non-int build number found: '%s'", buildStr)
} else {
res = append(res, num)
}
}
sort.Sort(sort.Reverse(sort.IntSlice(res)))
return res
} | go | {
"resource": ""
} |
q175927 | GetAll | test | func GetAll(sess *session.Session) ([]string, error) {
var regions []string
svc := ec2.New(sess, &aws.Config{Region: aws.String(Default)})
resp, err := svc.DescribeRegions(nil)
if err != nil {
return nil, err
}
for _, region := range resp.Regions {
regions = append(regions, *region.RegionName)
}
return regi... | go | {
"resource": ""
} |
q175928 | NewEventClient | test | func NewEventClient(ghc githubClient, log *logrus.Entry, org, repo string, number int) *EventClient {
return &EventClient{
org: org,
repo: repo,
number: number,
ghc: ghc,
log: log,
}
} | go | {
"resource": ""
} |
q175929 | PruneComments | test | func (c *EventClient) PruneComments(shouldPrune func(github.IssueComment) bool) {
c.once.Do(func() {
botName, err := c.ghc.BotName()
if err != nil {
c.log.WithError(err).Error("failed to get the bot's name. Pruning will consider all comments.")
}
comments, err := c.ghc.ListIssueComments(c.org, c.repo, c.num... | go | {
"resource": ""
} |
q175930 | FormatResponse | test | func FormatResponse(to, message, reason string) string {
format := `@%s: %s
<details>
%s
%s
</details>`
return fmt.Sprintf(format, to, message, reason, AboutThisBotWithoutCommands)
} | go | {
"resource": ""
} |
q175931 | FormatSimpleResponse | test | func FormatSimpleResponse(to, message string) string {
format := `@%s: %s
<details>
%s
</details>`
return fmt.Sprintf(format, to, message, AboutThisBotWithoutCommands)
} | go | {
"resource": ""
} |
q175932 | FormatICResponse | test | func FormatICResponse(ic github.IssueComment, s string) string {
return FormatResponseRaw(ic.Body, ic.HTMLURL, ic.User.Login, s)
} | go | {
"resource": ""
} |
q175933 | FormatResponseRaw | test | func FormatResponseRaw(body, bodyURL, login, reply string) string {
format := `In response to [this](%s):
%s
`
// Quote the user's comment by prepending ">" to each line.
var quoted []string
for _, l := range strings.Split(body, "\n") {
quoted = append(quoted, ">"+l)
}
return FormatResponse(login, reply, fmt.S... | go | {
"resource": ""
} |
q175934 | Validate | test | func (o *Options) Validate() error {
if o.gcsPath.String() != "" {
o.Bucket = o.gcsPath.Bucket()
o.PathPrefix = o.gcsPath.Object()
}
if !o.DryRun {
if o.Bucket == "" {
return errors.New("GCS upload was requested no GCS bucket was provided")
}
if o.GcsCredentialsFile == "" {
return errors.New("GCS u... | go | {
"resource": ""
} |
q175935 | Encode | test | func Encode(options Options) (string, error) {
encoded, err := json.Marshal(options)
return string(encoded), err
} | go | {
"resource": ""
} |
q175936 | RegisterIssueHandler | test | func RegisterIssueHandler(name string, fn IssueHandler, help HelpProvider) {
pluginHelp[name] = help
issueHandlers[name] = fn
} | go | {
"resource": ""
} |
q175937 | RegisterIssueCommentHandler | test | func RegisterIssueCommentHandler(name string, fn IssueCommentHandler, help HelpProvider) {
pluginHelp[name] = help
issueCommentHandlers[name] = fn
} | go | {
"resource": ""
} |
q175938 | RegisterPullRequestHandler | test | func RegisterPullRequestHandler(name string, fn PullRequestHandler, help HelpProvider) {
pluginHelp[name] = help
pullRequestHandlers[name] = fn
} | go | {
"resource": ""
} |
q175939 | RegisterStatusEventHandler | test | func RegisterStatusEventHandler(name string, fn StatusEventHandler, help HelpProvider) {
pluginHelp[name] = help
statusEventHandlers[name] = fn
} | go | {
"resource": ""
} |
q175940 | RegisterPushEventHandler | test | func RegisterPushEventHandler(name string, fn PushEventHandler, help HelpProvider) {
pluginHelp[name] = help
pushEventHandlers[name] = fn
} | go | {
"resource": ""
} |
q175941 | RegisterReviewEventHandler | test | func RegisterReviewEventHandler(name string, fn ReviewEventHandler, help HelpProvider) {
pluginHelp[name] = help
reviewEventHandlers[name] = fn
} | go | {
"resource": ""
} |
q175942 | RegisterReviewCommentEventHandler | test | func RegisterReviewCommentEventHandler(name string, fn ReviewCommentEventHandler, help HelpProvider) {
pluginHelp[name] = help
reviewCommentEventHandlers[name] = fn
} | go | {
"resource": ""
} |
q175943 | RegisterGenericCommentHandler | test | func RegisterGenericCommentHandler(name string, fn GenericCommentHandler, help HelpProvider) {
pluginHelp[name] = help
genericCommentHandlers[name] = fn
} | go | {
"resource": ""
} |
q175944 | NewAgent | test | func NewAgent(configAgent *config.Agent, pluginConfigAgent *ConfigAgent, clientAgent *ClientAgent, logger *logrus.Entry) Agent {
prowConfig := configAgent.Config()
pluginConfig := pluginConfigAgent.Config()
return Agent{
GitHubClient: clientAgent.GitHubClient,
KubernetesClient: clientAgent.KubernetesClient,
... | go | {
"resource": ""
} |
q175945 | InitializeCommentPruner | test | func (a *Agent) InitializeCommentPruner(org, repo string, pr int) {
a.commentPruner = commentpruner.NewEventClient(
a.GitHubClient, a.Logger.WithField("client", "commentpruner"),
org, repo, pr,
)
} | go | {
"resource": ""
} |
q175946 | CommentPruner | test | func (a *Agent) CommentPruner() (*commentpruner.EventClient, error) {
if a.commentPruner == nil {
return nil, errors.New("comment pruner client never initialized")
}
return a.commentPruner, nil
} | go | {
"resource": ""
} |
q175947 | Load | test | func (pa *ConfigAgent) Load(path string) error {
b, err := ioutil.ReadFile(path)
if err != nil {
return err
}
np := &Configuration{}
if err := yaml.Unmarshal(b, np); err != nil {
return err
}
if err := np.Validate(); err != nil {
return err
}
pa.Set(np)
return nil
} | go | {
"resource": ""
} |
q175948 | Config | test | func (pa *ConfigAgent) Config() *Configuration {
pa.mut.Lock()
defer pa.mut.Unlock()
return pa.configuration
} | go | {
"resource": ""
} |
q175949 | Set | test | func (pa *ConfigAgent) Set(pc *Configuration) {
pa.mut.Lock()
defer pa.mut.Unlock()
pa.configuration = pc
} | go | {
"resource": ""
} |
q175950 | Start | test | func (pa *ConfigAgent) Start(path string) error {
if err := pa.Load(path); err != nil {
return err
}
ticker := time.Tick(1 * time.Minute)
go func() {
for range ticker {
if err := pa.Load(path); err != nil {
logrus.WithField("path", path).WithError(err).Error("Error loading plugin config.")
}
}
}()
... | go | {
"resource": ""
} |
q175951 | GenericCommentHandlers | test | func (pa *ConfigAgent) GenericCommentHandlers(owner, repo string) map[string]GenericCommentHandler {
pa.mut.Lock()
defer pa.mut.Unlock()
hs := map[string]GenericCommentHandler{}
for _, p := range pa.getPlugins(owner, repo) {
if h, ok := genericCommentHandlers[p]; ok {
hs[p] = h
}
}
return hs
} | go | {
"resource": ""
} |
q175952 | IssueHandlers | test | func (pa *ConfigAgent) IssueHandlers(owner, repo string) map[string]IssueHandler {
pa.mut.Lock()
defer pa.mut.Unlock()
hs := map[string]IssueHandler{}
for _, p := range pa.getPlugins(owner, repo) {
if h, ok := issueHandlers[p]; ok {
hs[p] = h
}
}
return hs
} | go | {
"resource": ""
} |
q175953 | IssueCommentHandlers | test | func (pa *ConfigAgent) IssueCommentHandlers(owner, repo string) map[string]IssueCommentHandler {
pa.mut.Lock()
defer pa.mut.Unlock()
hs := map[string]IssueCommentHandler{}
for _, p := range pa.getPlugins(owner, repo) {
if h, ok := issueCommentHandlers[p]; ok {
hs[p] = h
}
}
return hs
} | go | {
"resource": ""
} |
q175954 | PullRequestHandlers | test | func (pa *ConfigAgent) PullRequestHandlers(owner, repo string) map[string]PullRequestHandler {
pa.mut.Lock()
defer pa.mut.Unlock()
hs := map[string]PullRequestHandler{}
for _, p := range pa.getPlugins(owner, repo) {
if h, ok := pullRequestHandlers[p]; ok {
hs[p] = h
}
}
return hs
} | go | {
"resource": ""
} |
q175955 | ReviewEventHandlers | test | func (pa *ConfigAgent) ReviewEventHandlers(owner, repo string) map[string]ReviewEventHandler {
pa.mut.Lock()
defer pa.mut.Unlock()
hs := map[string]ReviewEventHandler{}
for _, p := range pa.getPlugins(owner, repo) {
if h, ok := reviewEventHandlers[p]; ok {
hs[p] = h
}
}
return hs
} | go | {
"resource": ""
} |
q175956 | ReviewCommentEventHandlers | test | func (pa *ConfigAgent) ReviewCommentEventHandlers(owner, repo string) map[string]ReviewCommentEventHandler {
pa.mut.Lock()
defer pa.mut.Unlock()
hs := map[string]ReviewCommentEventHandler{}
for _, p := range pa.getPlugins(owner, repo) {
if h, ok := reviewCommentEventHandlers[p]; ok {
hs[p] = h
}
}
return... | go | {
"resource": ""
} |
q175957 | StatusEventHandlers | test | func (pa *ConfigAgent) StatusEventHandlers(owner, repo string) map[string]StatusEventHandler {
pa.mut.Lock()
defer pa.mut.Unlock()
hs := map[string]StatusEventHandler{}
for _, p := range pa.getPlugins(owner, repo) {
if h, ok := statusEventHandlers[p]; ok {
hs[p] = h
}
}
return hs
} | go | {
"resource": ""
} |
q175958 | PushEventHandlers | test | func (pa *ConfigAgent) PushEventHandlers(owner, repo string) map[string]PushEventHandler {
pa.mut.Lock()
defer pa.mut.Unlock()
hs := map[string]PushEventHandler{}
for _, p := range pa.getPlugins(owner, repo) {
if h, ok := pushEventHandlers[p]; ok {
hs[p] = h
}
}
return hs
} | go | {
"resource": ""
} |
q175959 | EventsForPlugin | test | func EventsForPlugin(name string) []string {
var events []string
if _, ok := issueHandlers[name]; ok {
events = append(events, "issue")
}
if _, ok := issueCommentHandlers[name]; ok {
events = append(events, "issue_comment")
}
if _, ok := pullRequestHandlers[name]; ok {
events = append(events, "pull_request"... | go | {
"resource": ""
} |
q175960 | insertLink | test | func insertLink(started *gcs.Started, viewURL string) (bool, error) {
if started.Metadata == nil {
started.Metadata = metadata.Metadata{}
}
meta := started.Metadata
var changed bool
top, present := meta.String(resultstoreKey)
if !present || top == nil || *top != viewURL {
changed = true
meta[resultstoreKey]... | go | {
"resource": ""
} |
q175961 | HelpProvider | test | func HelpProvider(enabledRepos []string) (*pluginhelp.PluginHelp, error) {
pluginHelp := &pluginhelp.PluginHelp{
Description: `The cherrypick plugin is used for cherrypicking PRs across branches. For every successful cherrypick invocation a new PR is opened against the target branch and assigned to the requester. If... | go | {
"resource": ""
} |
q175962 | getPatch | test | func (s *Server) getPatch(org, repo, targetBranch string, num int) (string, error) {
patch, err := s.ghc.GetPullRequestPatch(org, repo, num)
if err != nil {
return "", err
}
localPath := fmt.Sprintf("/tmp/%s_%s_%d_%s.patch", org, repo, num, normalize(targetBranch))
out, err := os.Create(localPath)
if err != nil... | go | {
"resource": ""
} |
q175963 | releaseNoteFromParentPR | test | func releaseNoteFromParentPR(body string) string {
potentialMatch := releaseNoteRe.FindStringSubmatch(body)
if potentialMatch == nil {
return ""
}
return fmt.Sprintf("```release-note\n%s\n```", strings.TrimSpace(potentialMatch[1]))
} | go | {
"resource": ""
} |
q175964 | ValidatePayload | test | func ValidatePayload(payload []byte, sig string, key []byte) bool {
if !strings.HasPrefix(sig, "sha1=") {
return false
}
sig = sig[5:]
sb, err := hex.DecodeString(sig)
if err != nil {
return false
}
mac := hmac.New(sha1.New, key)
mac.Write(payload)
expected := mac.Sum(nil)
return hmac.Equal(sb, expected)
... | go | {
"resource": ""
} |
q175965 | PayloadSignature | test | func PayloadSignature(payload []byte, key []byte) string {
mac := hmac.New(sha1.New, key)
mac.Write(payload)
sum := mac.Sum(nil)
return "sha1=" + hex.EncodeToString(sum)
} | go | {
"resource": ""
} |
q175966 | updateString | test | func updateString(have, want *string) bool {
switch {
case have == nil:
panic("have must be non-nil")
case want == nil:
return false // do not care what we have
case *have == *want:
return false // already have it
}
*have = *want // update value
return true
} | go | {
"resource": ""
} |
q175967 | updateBool | test | func updateBool(have, want *bool) bool {
switch {
case have == nil:
panic("have must not be nil")
case want == nil:
return false // do not care what we have
case *have == *want:
return false //already have it
}
*have = *want // update value
return true
} | go | {
"resource": ""
} |
q175968 | configureOrgMeta | test | func configureOrgMeta(client orgMetadataClient, orgName string, want org.Metadata) error {
cur, err := client.GetOrg(orgName)
if err != nil {
return fmt.Errorf("failed to get %s metadata: %v", orgName, err)
}
change := false
change = updateString(&cur.BillingEmail, want.BillingEmail) || change
change = updateSt... | go | {
"resource": ""
} |
q175969 | configureTeamRepos | test | func configureTeamRepos(client teamRepoClient, githubTeams map[string]github.Team, name, orgName string, team org.Team) error {
gt, ok := githubTeams[name]
if !ok { // configureTeams is buggy if this is the case
return fmt.Errorf("%s not found in id list", name)
}
want := team.Repos
have := map[string]github.Re... | go | {
"resource": ""
} |
q175970 | ShouldReport | test | func (c *Client) ShouldReport(pj *prowapi.ProwJob) bool {
pubSubMap := findLabels(pj, PubSubProjectLabel, PubSubTopicLabel)
return pubSubMap[PubSubProjectLabel] != "" && pubSubMap[PubSubTopicLabel] != ""
} | go | {
"resource": ""
} |
q175971 | Run | test | func (o Options) Run(spec *downwardapi.JobSpec, extra map[string]gcs.UploadFunc) error {
uploadTargets := o.assembleTargets(spec, extra)
if !o.DryRun {
ctx := context.Background()
gcsClient, err := storage.NewClient(ctx, option.WithCredentialsFile(o.GcsCredentialsFile))
if err != nil {
return fmt.Errorf("co... | go | {
"resource": ""
} |
q175972 | Format | test | func (d *DefaultFieldsFormatter) Format(entry *logrus.Entry) ([]byte, error) {
data := make(logrus.Fields, len(entry.Data)+len(d.DefaultFields))
for k, v := range d.DefaultFields {
data[k] = v
}
for k, v := range entry.Data {
data[k] = v
}
return d.WrappedFormatter.Format(&logrus.Entry{
Logger: entry.Logge... | go | {
"resource": ""
} |
q175973 | FindLabels | test | func (issue *Issue) FindLabels(regex *regexp.Regexp) []Label {
labels := []Label{}
for _, label := range issue.Labels {
if regex.MatchString(label.Name) {
labels = append(labels, label)
}
}
return labels
} | go | {
"resource": ""
} |
q175974 | AddFlags | test | func (o *Options) AddFlags(flags *flag.FlagSet) {
flags.StringVar(&o.Log, "clone-log", "", "Path to the clone records log")
o.Options.AddFlags(flags)
} | go | {
"resource": ""
} |
q175975 | NewAgent | test | func NewAgent(config *config.GitHubOAuthConfig, logger *logrus.Entry) *Agent {
return &Agent{
gc: config,
logger: logger,
}
} | go | {
"resource": ""
} |
q175976 | HandleLogin | test | func (ga *Agent) HandleLogin(client OAuthClient) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
stateToken := xsrftoken.Generate(ga.gc.ClientSecret, "", "")
state := hex.EncodeToString([]byte(stateToken))
oauthSession, err := ga.gc.CookieStore.New(r, oauthSessionCookie)
oauthSession.O... | go | {
"resource": ""
} |
q175977 | HandleLogout | test | func (ga *Agent) HandleLogout(client OAuthClient) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
accessTokenSession, err := ga.gc.CookieStore.Get(r, tokenSession)
if err != nil {
ga.serverError(w, "get cookie", err)
return
}
// Clear session
accessTokenSession.Options.MaxAge =... | go | {
"resource": ""
} |
q175978 | serverError | test | func (ga *Agent) serverError(w http.ResponseWriter, action string, err error) {
ga.logger.WithError(err).Errorf("Error %s.", action)
msg := fmt.Sprintf("500 Internal server error %s: %v", action, err)
http.Error(w, msg, http.StatusInternalServerError)
} | go | {
"resource": ""
} |
q175979 | FromItem | test | func (in *ResourcesConfigObject) FromItem(i common.Item) {
c, err := common.ItemToResourcesConfig(i)
if err == nil {
in.fromConfig(c)
}
} | go | {
"resource": ""
} |
q175980 | GetItems | test | func (in *ResourcesConfigCollection) GetItems() []Object {
var items []Object
for _, i := range in.Items {
items = append(items, i)
}
return items
} | go | {
"resource": ""
} |
q175981 | SetItems | test | func (in *ResourcesConfigCollection) SetItems(objects []Object) {
var items []*ResourcesConfigObject
for _, b := range objects {
items = append(items, b.(*ResourcesConfigObject))
}
in.Items = items
} | go | {
"resource": ""
} |
q175982 | UnmarshalText | test | func (l *RepoPermissionLevel) UnmarshalText(text []byte) error {
v := RepoPermissionLevel(text)
if _, ok := repoPermissionLevels[v]; !ok {
return fmt.Errorf("bad repo permission: %s not in %v", v, repoPermissionLevels)
}
*l = v
return nil
} | go | {
"resource": ""
} |
q175983 | IsAssignee | test | func (i Issue) IsAssignee(login string) bool {
for _, assignee := range i.Assignees {
if NormLogin(login) == NormLogin(assignee.Login) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q175984 | IsAuthor | test | func (i Issue) IsAuthor(login string) bool {
return NormLogin(i.User.Login) == NormLogin(login)
} | go | {
"resource": ""
} |
q175985 | HasLabel | test | func (i Issue) HasLabel(labelToFind string) bool {
for _, label := range i.Labels {
if strings.ToLower(label.Name) == strings.ToLower(labelToFind) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q175986 | Branch | test | func (pe PushEvent) Branch() string {
ref := strings.TrimPrefix(pe.Ref, "refs/heads/") // if Ref is a branch
ref = strings.TrimPrefix(ref, "refs/tags/") // if Ref is a tag
return ref
} | go | {
"resource": ""
} |
q175987 | truncate | test | func truncate(in string) string {
const (
half = (maxLen - len(elide)) / 2
)
if len(in) <= maxLen {
return in
}
return in[:half] + elide + in[len(in)-half:]
} | go | {
"resource": ""
} |
q175988 | reportStatus | test | func reportStatus(ghc GitHubClient, pj prowapi.ProwJob) error {
refs := pj.Spec.Refs
if pj.Spec.Report {
contextState, err := prowjobStateToGitHubStatus(pj.Status.State)
if err != nil {
return err
}
sha := refs.BaseSHA
if len(refs.Pulls) > 0 {
sha = refs.Pulls[0].SHA
}
if err := ghc.CreateStatus(r... | go | {
"resource": ""
} |
q175989 | parseIssueComments | test | func parseIssueComments(pj prowapi.ProwJob, botName string, ics []github.IssueComment) ([]int, []string, int) {
var delete []int
var previousComments []int
var latestComment int
var entries []string
// First accumulate result entries and comment IDs
for _, ic := range ics {
if ic.User.Login != botName {
cont... | go | {
"resource": ""
} |
q175990 | createComment | test | func createComment(reportTemplate *template.Template, pj prowapi.ProwJob, entries []string) (string, error) {
plural := ""
if len(entries) > 1 {
plural = "s"
}
var b bytes.Buffer
if reportTemplate != nil {
if err := reportTemplate.Execute(&b, &pj); err != nil {
return "", err
}
}
lines := []string{
fm... | go | {
"resource": ""
} |
q175991 | Config | test | func (lens Lens) Config() lenses.LensConfig {
return lenses.LensConfig{
Name: name,
Title: title,
Priority: priority,
}
} | go | {
"resource": ""
} |
q175992 | Callback | test | func (lens Lens) Callback(artifacts []lenses.Artifact, resourceDir string, data string) string {
return ""
} | go | {
"resource": ""
} |
q175993 | FormatRecord | test | func FormatRecord(record Record) string {
output := bytes.Buffer{}
if record.Failed {
fmt.Fprintln(&output, "# FAILED!")
}
fmt.Fprintf(&output, "# Cloning %s/%s at %s", record.Refs.Org, record.Refs.Repo, record.Refs.BaseRef)
if record.Refs.BaseSHA != "" {
fmt.Fprintf(&output, "(%s)", record.Refs.BaseSHA)
}
o... | go | {
"resource": ""
} |
q175994 | Namespace | test | func (c *Client) Namespace(ns string) *Client {
nc := *c
nc.namespace = ns
return &nc
} | go | {
"resource": ""
} |
q175995 | NewFakeClient | test | func NewFakeClient(deckURL string) *Client {
return &Client{
namespace: "default",
deckURL: deckURL,
client: &http.Client{},
fake: true,
}
} | go | {
"resource": ""
} |
q175996 | NewClientInCluster | test | func NewClientInCluster(namespace string) (*Client, error) {
tokenFile := "/var/run/secrets/kubernetes.io/serviceaccount/token"
token, err := ioutil.ReadFile(tokenFile)
if err != nil {
return nil, err
}
rootCAFile := "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
certData, err := ioutil.ReadFile(rootCA... | go | {
"resource": ""
} |
q175997 | NewClientFromFile | test | func NewClientFromFile(clusterPath, namespace string) (*Client, error) {
data, err := ioutil.ReadFile(clusterPath)
if err != nil {
return nil, err
}
var c Cluster
if err := yaml.Unmarshal(data, &c); err != nil {
return nil, err
}
return NewClient(&c, namespace)
} | go | {
"resource": ""
} |
q175998 | NewClient | test | func NewClient(c *Cluster, namespace string) (*Client, error) {
// Relies on json encoding/decoding []byte as base64
// https://golang.org/pkg/encoding/json/#Marshal
cc := c.ClientCertificate
ck := c.ClientKey
ca := c.ClusterCACertificate
cert, err := tls.X509KeyPair(cc, ck)
if err != nil {
return nil, err
}... | go | {
"resource": ""
} |
q175999 | ReplaceConfigMap | test | func (c *Client) ReplaceConfigMap(name string, config ConfigMap) (ConfigMap, error) {
c.log("ReplaceConfigMap", name)
namespace := c.namespace
if config.Namespace != "" {
namespace = config.Namespace
}
var retConfigMap ConfigMap
err := c.request(&request{
method: http.MethodPut,
path: fmt.Sprint... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.