_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q176400 | parseXML | test | func parseXML(body []byte, object string) (*gcsDir, error) {
dir := new(gcsDir)
if err := xml.Unmarshal(body, &dir); err != nil {
return nil, err
}
// We think this is a dir if the object is "/" (just the bucket) or if we
// find any Contents or CommonPrefixes.
isDir := object == "/" || len(dir.Contents)+len(di... | go | {
"resource": ""
} |
q176401 | Render | test | func (dir *gcsDir) Render(out http.ResponseWriter, inPath string) {
htmlPageHeader(out, dir.Name)
if !strings.HasSuffix(inPath, "/") {
inPath += "/"
}
htmlContentHeader(out, dir.Name, inPath)
if dir.NextMarker != "" {
htmlNextButton(out, gcsPath+inPath, dir.NextMarker)
}
htmlGridHeader(out)
if parent :=... | go | {
"resource": ""
} |
q176402 | Render | test | func (rec *Record) Render(out http.ResponseWriter, inPath string) {
mtime := "<unknown>"
ts, err := time.Parse(time.RFC3339, rec.MTime)
if err == nil {
mtime = ts.Format("02 Jan 2006 15:04:05")
}
var url, size string
if rec.isDir {
url = gcsPath + inPath + rec.Name
size = "-"
} else {
url = gcsBaseURL + ... | go | {
"resource": ""
} |
q176403 | Render | test | func (pfx *Prefix) Render(out http.ResponseWriter, inPath string) {
url := gcsPath + inPath + pfx.Prefix
htmlGridItem(out, iconDir, url, pfx.Prefix, "-", "-")
} | go | {
"resource": ""
} |
q176404 | Printf | test | func (tl txnLogger) Printf(fmt string, args ...interface{}) {
args = append([]interface{}{tl.nonce}, args...)
log.Printf("[txn-%s] "+fmt, args...)
} | go | {
"resource": ""
} |
q176405 | NewClient | test | func NewClient(instances map[string][]string) (*Client, error) {
c := &Client{
handlers: map[string]*gerritInstanceHandler{},
}
for instance := range instances {
gc, err := gerrit.NewClient(instance, nil)
if err != nil {
return nil, err
}
c.handlers[instance] = &gerritInstanceHandler{
instance: ... | go | {
"resource": ""
} |
q176406 | SetReview | test | func (c *Client) SetReview(instance, id, revision, message string, labels map[string]string) error {
h, ok := c.handlers[instance]
if !ok {
return fmt.Errorf("not activated gerrit instance: %s", instance)
}
if _, _, err := h.changeService.SetReview(id, revision, &gerrit.ReviewInput{
Message: message,
Labels:... | go | {
"resource": ""
} |
q176407 | GetBranchRevision | test | func (c *Client) GetBranchRevision(instance, project, branch string) (string, error) {
h, ok := c.handlers[instance]
if !ok {
return "", fmt.Errorf("not activated gerrit instance: %s", instance)
}
res, _, err := h.projectService.GetBranch(project, branch)
if err != nil {
return "", err
}
return res.Revisio... | go | {
"resource": ""
} |
q176408 | queryAllChanges | test | func (h *gerritInstanceHandler) queryAllChanges(lastUpdate time.Time, rateLimit int) []gerrit.ChangeInfo {
result := []gerrit.ChangeInfo{}
for _, project := range h.projects {
changes, err := h.queryChangesForProject(project, lastUpdate, rateLimit)
if err != nil {
// don't halt on error from one project, log &... | go | {
"resource": ""
} |
q176409 | NewTypeFilterWrapperPlugin | test | func NewTypeFilterWrapperPlugin(plugin Plugin) *TypeFilterWrapperPlugin {
return &TypeFilterWrapperPlugin{
plugin: plugin,
pass: map[string]bool{},
}
} | go | {
"resource": ""
} |
q176410 | AddFlags | test | func (t *TypeFilterWrapperPlugin) AddFlags(cmd *cobra.Command) {
cmd.Flags().BoolVar(&t.pullRequests, "no-pull-requests", false, "Ignore pull-requests")
cmd.Flags().BoolVar(&t.issues, "no-issues", false, "Ignore issues")
} | go | {
"resource": ""
} |
q176411 | CheckFlags | test | func (t *TypeFilterWrapperPlugin) CheckFlags() error {
if t.pullRequests && t.issues {
return fmt.Errorf(
"you can't ignore both pull-requests and issues")
}
return nil
} | go | {
"resource": ""
} |
q176412 | AddFlags | test | func (o *KubernetesClientOptions) AddFlags(fs *flag.FlagSet) {
fs.StringVar(&o.namespace, "namespace", v1.NamespaceDefault, "namespace to install on")
fs.StringVar(&o.kubeConfig, "kubeconfig", "", "absolute path to the kubeConfig file")
fs.BoolVar(&o.inMemory, "in_memory", false, "Use in memory client instead of CRD... | go | {
"resource": ""
} |
q176413 | Validate | test | func (o *KubernetesClientOptions) Validate() error {
if o.kubeConfig != "" {
if _, err := os.Stat(o.kubeConfig); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q176414 | Client | test | func (o *KubernetesClientOptions) Client(t Type) (ClientInterface, error) {
if o.inMemory {
return newDummyClient(t), nil
}
return o.newCRDClient(t)
} | go | {
"resource": ""
} |
q176415 | newCRDClient | test | func (o *KubernetesClientOptions) newCRDClient(t Type) (*Client, error) {
config, scheme, err := createRESTConfig(o.kubeConfig, t)
if err != nil {
return nil, err
}
if err = registerResource(config, t); err != nil {
return nil, err
}
// creates the client
var restClient *rest.RESTClient
restClient, err = r... | go | {
"resource": ""
} |
q176416 | createRESTConfig | test | func createRESTConfig(kubeconfig string, t Type) (config *rest.Config, types *runtime.Scheme, err error) {
if kubeconfig == "" {
config, err = rest.InClusterConfig()
} else {
config, err = clientcmd.BuildConfigFromFlags("", kubeconfig)
}
if err != nil {
return
}
version := schema.GroupVersion{
Group: ... | go | {
"resource": ""
} |
q176417 | registerResource | test | func registerResource(config *rest.Config, t Type) error {
c, err := apiextensionsclient.NewForConfig(config)
if err != nil {
return err
}
crd := &apiextensionsv1beta1.CustomResourceDefinition{
ObjectMeta: v1.ObjectMeta{
Name: fmt.Sprintf("%s.%s", t.Plural, group),
},
Spec: apiextensionsv1beta1.CustomRe... | go | {
"resource": ""
} |
q176418 | newDummyClient | test | func newDummyClient(t Type) *dummyClient {
c := &dummyClient{
t: t,
objects: make(map[string]Object),
}
return c
} | go | {
"resource": ""
} |
q176419 | Update | test | func (c *dummyClient) Update(obj Object) (Object, error) {
_, ok := c.objects[obj.GetName()]
if !ok {
return nil, fmt.Errorf("cannot find object %s", obj.GetName())
}
c.objects[obj.GetName()] = obj
return obj, nil
} | go | {
"resource": ""
} |
q176420 | TrustedPullRequest | test | func TrustedPullRequest(ghc githubClient, trigger plugins.Trigger, author, org, repo string, num int, l []github.Label) ([]github.Label, bool, error) {
// First check if the author is a member of the org.
if orgMember, err := TrustedUser(ghc, trigger, author, org, repo); err != nil {
return l, false, fmt.Errorf("er... | go | {
"resource": ""
} |
q176421 | buildAll | test | func buildAll(c Client, pr *github.PullRequest, eventGUID string, elideSkippedContexts bool) error {
org, repo, number, branch := pr.Base.Repo.Owner.Login, pr.Base.Repo.Name, pr.Number, pr.Base.Ref
changes := config.NewGitHubDeferredChangedFilesProvider(c.GitHubClient, org, repo, number)
toTest, toSkipSuperset, err ... | go | {
"resource": ""
} |
q176422 | Run | test | func (o Options) Run(ctx context.Context) (int, error) {
spec, err := downwardapi.ResolveSpecFromEnv()
if err != nil {
return 0, fmt.Errorf("could not resolve job spec: %v", err)
}
ctx, cancel := context.WithCancel(ctx)
// If we are being asked to terminate by the kubelet but we have
// NOT seen the test proc... | go | {
"resource": ""
} |
q176423 | AddConfig | test | func (s *Storage) AddConfig(conf common.ResourcesConfig) error {
return s.configs.Add(conf)
} | go | {
"resource": ""
} |
q176424 | DeleteConfig | test | func (s *Storage) DeleteConfig(name string) error {
return s.configs.Delete(name)
} | go | {
"resource": ""
} |
q176425 | UpdateConfig | test | func (s *Storage) UpdateConfig(conf common.ResourcesConfig) error {
return s.configs.Update(conf)
} | go | {
"resource": ""
} |
q176426 | GetConfig | test | func (s *Storage) GetConfig(name string) (common.ResourcesConfig, error) {
i, err := s.configs.Get(name)
if err != nil {
return common.ResourcesConfig{}, err
}
var conf common.ResourcesConfig
conf, err = common.ItemToResourcesConfig(i)
if err != nil {
return common.ResourcesConfig{}, err
}
return conf, nil
... | go | {
"resource": ""
} |
q176427 | GetConfigs | test | func (s *Storage) GetConfigs() ([]common.ResourcesConfig, error) {
var configs []common.ResourcesConfig
items, err := s.configs.List()
if err != nil {
return configs, err
}
for _, i := range items {
var conf common.ResourcesConfig
conf, err = common.ItemToResourcesConfig(i)
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q176428 | SyncConfigs | test | func (s *Storage) SyncConfigs(newConfigs []common.ResourcesConfig) error {
s.configsLock.Lock()
defer s.configsLock.Unlock()
currentConfigs, err := s.GetConfigs()
if err != nil {
logrus.WithError(err).Error("cannot find configs")
return err
}
currentSet := mapset.NewSet()
newSet := mapset.NewSet()
toUpdat... | go | {
"resource": ""
} |
q176429 | addKnownTypes | test | func addKnownTypes(scheme *runtime.Scheme) error {
scheme.AddKnownTypes(SchemeGroupVersion,
&ProwJob{},
&ProwJobList{},
)
metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
return nil
} | go | {
"resource": ""
} |
q176430 | NewController | test | func NewController(continueOnError bool, addedPresubmitBlacklist sets.String, prowJobClient prowv1.ProwJobInterface, githubClient *github.Client, configAgent *config.Agent, pluginAgent *plugins.ConfigAgent) *Controller {
return &Controller{
continueOnError: continueOnError,
addedPresubmitBlacklist: addedPr... | go | {
"resource": ""
} |
q176431 | Run | test | func (c *Controller) Run(stop <-chan os.Signal, changes <-chan config.Delta) {
for {
select {
case change := <-changes:
start := time.Now()
if err := c.reconcile(change); err != nil {
logrus.WithError(err).Error("Error reconciling statuses.")
}
logrus.WithField("duration", fmt.Sprintf("%v", time.Si... | go | {
"resource": ""
} |
q176432 | addedBlockingPresubmits | test | func addedBlockingPresubmits(old, new map[string][]config.Presubmit) map[string][]config.Presubmit {
added := map[string][]config.Presubmit{}
for repo, oldPresubmits := range old {
added[repo] = []config.Presubmit{}
for _, newPresubmit := range new[repo] {
if !newPresubmit.ContextRequired() || newPresubmit.Ne... | go | {
"resource": ""
} |
q176433 | removedBlockingPresubmits | test | func removedBlockingPresubmits(old, new map[string][]config.Presubmit) map[string][]config.Presubmit {
removed := map[string][]config.Presubmit{}
for repo, oldPresubmits := range old {
removed[repo] = []config.Presubmit{}
for _, oldPresubmit := range oldPresubmits {
if !oldPresubmit.ContextRequired() {
co... | go | {
"resource": ""
} |
q176434 | migratedBlockingPresubmits | test | func migratedBlockingPresubmits(old, new map[string][]config.Presubmit) map[string][]presubmitMigration {
migrated := map[string][]presubmitMigration{}
for repo, oldPresubmits := range old {
migrated[repo] = []presubmitMigration{}
for _, newPresubmit := range new[repo] {
if !newPresubmit.ContextRequired() {
... | go | {
"resource": ""
} |
q176435 | Load | test | func Load(loader OptionLoader) error {
if jsonConfig, provided := os.LookupEnv(loader.ConfigVar()); provided {
if err := loader.LoadConfig(jsonConfig); err != nil {
return fmt.Errorf("could not load config from JSON var %s: %v", loader.ConfigVar(), err)
}
return nil
}
fs := flag.NewFlagSet(os.Args[0], flag... | go | {
"resource": ""
} |
q176436 | canExecuteConcurrently | test | func (c *Controller) canExecuteConcurrently(pj *prowapi.ProwJob) bool {
c.lock.Lock()
defer c.lock.Unlock()
if max := c.config().MaxConcurrency; max > 0 {
var running int
for _, num := range c.pendingJobs {
running += num
}
if running >= max {
c.log.WithFields(pjutil.ProwJobFields(pj)).Debugf("Not sta... | go | {
"resource": ""
} |
q176437 | getJenkinsJobs | test | func getJenkinsJobs(pjs []prowapi.ProwJob) []BuildQueryParams {
jenkinsJobs := []BuildQueryParams{}
for _, pj := range pjs {
if pj.Complete() {
continue
}
jenkinsJobs = append(jenkinsJobs, BuildQueryParams{
JobName: getJobName(&pj.Spec),
ProwJobID: pj.Name,
})
}
return jenkinsJobs
} | go | {
"resource": ""
} |
q176438 | terminateDupes | test | func (c *Controller) terminateDupes(pjs []prowapi.ProwJob, jbs map[string]Build) error {
// "job org/repo#number" -> newest job
dupes := make(map[string]int)
for i, pj := range pjs {
if pj.Complete() || pj.Spec.Type != prowapi.PresubmitJob {
continue
}
n := fmt.Sprintf("%s %s/%s#%d", pj.Spec.Job, pj.Spec.Re... | go | {
"resource": ""
} |
q176439 | Throttle | test | func (c *Client) Throttle(hourlyTokens, burst int) {
c.log("Throttle", hourlyTokens, burst)
c.throttle.lock.Lock()
defer c.throttle.lock.Unlock()
previouslyThrottled := c.throttle.ticker != nil
if hourlyTokens <= 0 || burst <= 0 { // Disable throttle
if previouslyThrottled { // Unwrap clients if necessary
c.c... | go | {
"resource": ""
} |
q176440 | NewClientWithFields | test | func NewClientWithFields(fields logrus.Fields, getToken func() []byte, graphqlEndpoint string, bases ...string) *Client {
return &Client{
logger: logrus.WithFields(fields).WithField("client", "github"),
time: &standardTime{},
gqlc: githubql.NewEnterpriseClient(
graphqlEndpoint,
&http.Client{
Timeout:... | go | {
"resource": ""
} |
q176441 | NewClient | test | func NewClient(getToken func() []byte, graphqlEndpoint string, bases ...string) *Client {
return NewClientWithFields(logrus.Fields{}, getToken, graphqlEndpoint, bases...)
} | go | {
"resource": ""
} |
q176442 | NewDryRunClient | test | func NewDryRunClient(getToken func() []byte, graphqlEndpoint string, bases ...string) *Client {
return NewDryRunClientWithFields(logrus.Fields{}, getToken, graphqlEndpoint, bases...)
} | go | {
"resource": ""
} |
q176443 | NewFakeClient | test | func NewFakeClient() *Client {
return &Client{
logger: logrus.WithField("client", "github"),
time: &standardTime{},
fake: true,
dry: true,
}
} | go | {
"resource": ""
} |
q176444 | request | test | func (c *Client) request(r *request, ret interface{}) (int, error) {
statusCode, b, err := c.requestRaw(r)
if err != nil {
return statusCode, err
}
if ret != nil {
if err := json.Unmarshal(b, ret); err != nil {
return statusCode, err
}
}
return statusCode, nil
} | go | {
"resource": ""
} |
q176445 | requestRaw | test | func (c *Client) requestRaw(r *request) (int, []byte, error) {
if c.fake || (c.dry && r.method != http.MethodGet) {
return r.exitCodes[0], nil, nil
}
resp, err := c.requestRetry(r.method, r.path, r.accept, r.requestBody)
if err != nil {
return 0, nil, err
}
defer resp.Body.Close()
b, err := ioutil.ReadAll(re... | go | {
"resource": ""
} |
q176446 | getUserData | test | func (c *Client) getUserData() error {
c.log("User")
var u User
_, err := c.request(&request{
method: http.MethodGet,
path: "/user",
exitCodes: []int{200},
}, &u)
if err != nil {
return err
}
c.botName = u.Login
// email needs to be publicly accessible via the profile
// of the current account.... | go | {
"resource": ""
} |
q176447 | readPaginatedResultsWithValues | test | func (c *Client) readPaginatedResultsWithValues(path string, values url.Values, accept string, newObj func() interface{}, accumulate func(interface{})) error {
pagedPath := path
if len(values) > 0 {
pagedPath += "?" + values.Encode()
}
for {
resp, err := c.requestRetry(http.MethodGet, pagedPath, accept, nil)
... | go | {
"resource": ""
} |
q176448 | UpdatePullRequest | test | func (c *Client) UpdatePullRequest(org, repo string, number int, title, body *string, open *bool, branch *string, canModify *bool) error {
c.log("UpdatePullRequest", org, repo, title)
data := struct {
State *string `json:"state,omitempty"`
Title *string `json:"title,omitempty"`
Body *string `json:"body,omitemp... | go | {
"resource": ""
} |
q176449 | getLabels | test | func (c *Client) getLabels(path string) ([]Label, error) {
var labels []Label
if c.fake {
return labels, nil
}
err := c.readPaginatedResults(
path,
"application/vnd.github.symmetra-preview+json", // allow the description field -- https://developer.github.com/changes/2018-02-22-label-description-search-preview... | go | {
"resource": ""
} |
q176450 | stateCannotBeChangedOrOriginalError | test | func stateCannotBeChangedOrOriginalError(err error) error {
requestErr, ok := err.(requestError)
if ok {
for _, errorMsg := range requestErr.ErrorMessages() {
if strings.Contains(errorMsg, stateCannotBeChangedMessagePrefix) {
return StateCannotBeChanged{
Message: errorMsg,
}
}
}
}
return err
... | go | {
"resource": ""
} |
q176451 | IsMergeable | test | func (c *Client) IsMergeable(org, repo string, number int, SHA string) (bool, error) {
backoff := time.Second * 3
maxTries := 3
for try := 0; try < maxTries; try++ {
pr, err := c.GetPullRequest(org, repo, number)
if err != nil {
return false, err
}
if pr.Head.SHA != SHA {
return false, fmt.Errorf("pull... | go | {
"resource": ""
} |
q176452 | Token | test | func (s *reloadingTokenSource) Token() (*oauth2.Token, error) {
return &oauth2.Token{
AccessToken: string(s.getToken()),
}, nil
} | go | {
"resource": ""
} |
q176453 | ListArtifacts | test | func (s *Spyglass) ListArtifacts(src string) ([]string, error) {
keyType, key, err := splitSrc(src)
if err != nil {
return []string{}, fmt.Errorf("error parsing src: %v", err)
}
gcsKey := ""
switch keyType {
case gcsKeyType:
gcsKey = key
case prowKeyType:
if gcsKey, err = s.prowToGCS(key); err != nil {
... | go | {
"resource": ""
} |
q176454 | KeyToJob | test | func (*Spyglass) KeyToJob(src string) (jobName string, buildID string, err error) {
src = strings.Trim(src, "/")
parsed := strings.Split(src, "/")
if len(parsed) < 2 {
return "", "", fmt.Errorf("expected at least two path components in %q", src)
}
jobName = parsed[len(parsed)-2]
buildID = parsed[len(parsed)-1]
... | go | {
"resource": ""
} |
q176455 | prowToGCS | test | func (s *Spyglass) prowToGCS(prowKey string) (string, error) {
jobName, buildID, err := s.KeyToJob(prowKey)
if err != nil {
return "", fmt.Errorf("could not get GCS src: %v", err)
}
job, err := s.jobAgent.GetProwJob(jobName, buildID)
if err != nil {
return "", fmt.Errorf("Failed to get prow job from src %q: %... | go | {
"resource": ""
} |
q176456 | FetchArtifacts | test | func (s *Spyglass) FetchArtifacts(src string, podName string, sizeLimit int64, artifactNames []string) ([]lenses.Artifact, error) {
artStart := time.Now()
arts := []lenses.Artifact{}
keyType, key, err := splitSrc(src)
if err != nil {
return arts, fmt.Errorf("error parsing src: %v", err)
}
jobName, buildID, err ... | go | {
"resource": ""
} |
q176457 | DeepCopy | test | func (in *DecorationConfig) DeepCopy() *DecorationConfig {
if in == nil {
return nil
}
out := new(DecorationConfig)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176458 | DeepCopy | test | func (in *GCSConfiguration) DeepCopy() *GCSConfiguration {
if in == nil {
return nil
}
out := new(GCSConfiguration)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176459 | DeepCopy | test | func (in *JenkinsSpec) DeepCopy() *JenkinsSpec {
if in == nil {
return nil
}
out := new(JenkinsSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176460 | DeepCopy | test | func (in *ProwJob) DeepCopy() *ProwJob {
if in == nil {
return nil
}
out := new(ProwJob)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176461 | DeepCopy | test | func (in *ProwJobList) DeepCopy() *ProwJobList {
if in == nil {
return nil
}
out := new(ProwJobList)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176462 | DeepCopy | test | func (in *ProwJobSpec) DeepCopy() *ProwJobSpec {
if in == nil {
return nil
}
out := new(ProwJobSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176463 | DeepCopy | test | func (in *ProwJobStatus) DeepCopy() *ProwJobStatus {
if in == nil {
return nil
}
out := new(ProwJobStatus)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176464 | DeepCopy | test | func (in *Pull) DeepCopy() *Pull {
if in == nil {
return nil
}
out := new(Pull)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176465 | DeepCopy | test | func (in *Refs) DeepCopy() *Refs {
if in == nil {
return nil
}
out := new(Refs)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176466 | DeepCopy | test | func (in *UtilityImages) DeepCopy() *UtilityImages {
if in == nil {
return nil
}
out := new(UtilityImages)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q176467 | upload | test | func upload(rsClient *resultstore.Client, inv resultstore.Invocation, target resultstore.Target, test resultstore.Test) (string, error) {
targetID := test.Name
const configID = resultstore.Default
invName, err := rsClient.Invocations().Create(inv)
if err != nil {
return "", fmt.Errorf("create invocation: %v", er... | go | {
"resource": ""
} |
q176468 | ApplyDefault | test | func (d *DecorationConfig) ApplyDefault(def *DecorationConfig) *DecorationConfig {
if d == nil && def == nil {
return nil
}
var merged DecorationConfig
if d != nil {
merged = *d
} else {
merged = *def
}
if d == nil || def == nil {
return &merged
}
merged.UtilityImages = merged.UtilityImages.ApplyDefaul... | go | {
"resource": ""
} |
q176469 | Validate | test | func (d *DecorationConfig) Validate() error {
if d.UtilityImages == nil {
return errors.New("utility image config is not specified")
}
var missing []string
if d.UtilityImages.CloneRefs == "" {
missing = append(missing, "clonerefs")
}
if d.UtilityImages.InitUpload == "" {
missing = append(missing, "inituploa... | go | {
"resource": ""
} |
q176470 | ApplyDefault | test | func (u *UtilityImages) ApplyDefault(def *UtilityImages) *UtilityImages {
if u == nil {
return def
} else if def == nil {
return u
}
merged := *u
if merged.CloneRefs == "" {
merged.CloneRefs = def.CloneRefs
}
if merged.InitUpload == "" {
merged.InitUpload = def.InitUpload
}
if merged.Entrypoint == "" ... | go | {
"resource": ""
} |
q176471 | ApplyDefault | test | func (g *GCSConfiguration) ApplyDefault(def *GCSConfiguration) *GCSConfiguration {
if g == nil && def == nil {
return nil
}
var merged GCSConfiguration
if g != nil {
merged = *g
} else {
merged = *def
}
if g == nil || def == nil {
return &merged
}
if merged.Bucket == "" {
merged.Bucket = def.Bucket
... | go | {
"resource": ""
} |
q176472 | Validate | test | func (g *GCSConfiguration) Validate() error {
if g.PathStrategy != PathStrategyLegacy && g.PathStrategy != PathStrategyExplicit && g.PathStrategy != PathStrategySingle {
return fmt.Errorf("gcs_path_strategy must be one of %q, %q, or %q", PathStrategyLegacy, PathStrategyExplicit, PathStrategySingle)
}
if g.PathStra... | go | {
"resource": ""
} |
q176473 | ClusterAlias | test | func (j *ProwJob) ClusterAlias() string {
if j.Spec.Cluster == "" {
return DefaultClusterAlias
}
return j.Spec.Cluster
} | go | {
"resource": ""
} |
q176474 | NewResource | test | func NewResource(name, rtype, state, owner string, t time.Time) Resource {
return Resource{
Name: name,
Type: rtype,
State: state,
Owner: owner,
LastUpdate: t,
UserData: &UserData{},
}
} | go | {
"resource": ""
} |
q176475 | NewResourcesFromConfig | test | func NewResourcesFromConfig(e ResourceEntry) []Resource {
var resources []Resource
for _, name := range e.Names {
resources = append(resources, NewResource(name, e.Type, e.State, "", time.Time{}))
}
return resources
} | go | {
"resource": ""
} |
q176476 | UserDataFromMap | test | func UserDataFromMap(m UserDataMap) *UserData {
ud := &UserData{}
for k, v := range m {
ud.Store(k, v)
}
return ud
} | go | {
"resource": ""
} |
q176477 | Set | test | func (r *CommaSeparatedStrings) Set(value string) error {
if len(*r) > 0 {
return errors.New("resTypes flag already set")
}
for _, rtype := range strings.Split(value, ",") {
*r = append(*r, rtype)
}
return nil
} | go | {
"resource": ""
} |
q176478 | UnmarshalJSON | test | func (ud *UserData) UnmarshalJSON(data []byte) error {
tmpMap := UserDataMap{}
if err := json.Unmarshal(data, &tmpMap); err != nil {
return err
}
ud.FromMap(tmpMap)
return nil
} | go | {
"resource": ""
} |
q176479 | Extract | test | func (ud *UserData) Extract(id string, out interface{}) error {
content, ok := ud.Load(id)
if !ok {
return &UserDataNotFound{id}
}
return yaml.Unmarshal([]byte(content.(string)), out)
} | go | {
"resource": ""
} |
q176480 | Set | test | func (ud *UserData) Set(id string, in interface{}) error {
b, err := yaml.Marshal(in)
if err != nil {
return err
}
ud.Store(id, string(b))
return nil
} | go | {
"resource": ""
} |
q176481 | Update | test | func (ud *UserData) Update(new *UserData) {
if new == nil {
return
}
new.Range(func(key, value interface{}) bool {
if value.(string) != "" {
ud.Store(key, value)
} else {
ud.Delete(key)
}
return true
})
} | go | {
"resource": ""
} |
q176482 | ToMap | test | func (ud *UserData) ToMap() UserDataMap {
m := UserDataMap{}
ud.Range(func(key, value interface{}) bool {
m[key.(string)] = value.(string)
return true
})
return m
} | go | {
"resource": ""
} |
q176483 | FromMap | test | func (ud *UserData) FromMap(m UserDataMap) {
for key, value := range m {
ud.Store(key, value)
}
} | go | {
"resource": ""
} |
q176484 | ItemToResource | test | func ItemToResource(i Item) (Resource, error) {
res, ok := i.(Resource)
if !ok {
return Resource{}, fmt.Errorf("cannot construct Resource from received object %v", i)
}
return res, nil
} | go | {
"resource": ""
} |
q176485 | Run | test | func (o Options) Run() error {
var env []string
if len(o.KeyFiles) > 0 {
var err error
env, err = addSSHKeys(o.KeyFiles)
if err != nil {
logrus.WithError(err).Error("Failed to add SSH keys.")
// Continue on error. Clones will fail with an appropriate error message
// that initupload can consume whereas... | go | {
"resource": ""
} |
q176486 | addSSHKeys | test | func addSSHKeys(paths []string) ([]string, error) {
vars, err := exec.Command("ssh-agent").CombinedOutput()
if err != nil {
return []string{}, fmt.Errorf("failed to start ssh-agent: %v", err)
}
logrus.Info("Started SSH agent")
// ssh-agent will output three lines of text, in the form:
// SSH_AUTH_SOCK=xxx; expo... | go | {
"resource": ""
} |
q176487 | Issues | test | func (f *TriageFiler) Issues(c *creator.IssueCreator) ([]creator.Issue, error) {
f.creator = c
rawjson, err := ReadHTTP(clusterDataURL)
if err != nil {
return nil, err
}
clusters, err := f.loadClusters(rawjson)
if err != nil {
return nil, err
}
topclusters := topClusters(clusters, f.topClustersCount)
issue... | go | {
"resource": ""
} |
q176488 | loadClusters | test | func (f *TriageFiler) loadClusters(jsonIn []byte) ([]*Cluster, error) {
var err error
f.data, err = parseTriageData(jsonIn)
if err != nil {
return nil, err
}
if err = f.filterAndValidate(f.windowDays); err != nil {
return nil, err
}
// Aggregate failing builds in each cluster by job (independent of tests).
... | go | {
"resource": ""
} |
q176489 | parseTriageData | test | func parseTriageData(jsonIn []byte) (*triageData, error) {
var data triageData
if err := json.Unmarshal(jsonIn, &data); err != nil {
return nil, err
}
if data.Builds.Cols.Started == nil {
return nil, fmt.Errorf("triage data json is missing the builds.cols.started key")
}
if data.Builds.JobsRaw == nil {
ret... | go | {
"resource": ""
} |
q176490 | topClusters | test | func topClusters(clusters []*Cluster, count int) []*Cluster {
less := func(i, j int) bool { return clusters[i].totalBuilds > clusters[j].totalBuilds }
sort.SliceStable(clusters, less)
if len(clusters) < count {
count = len(clusters)
}
return clusters[0:count]
} | go | {
"resource": ""
} |
q176491 | topJobsFailed | test | func (c *Cluster) topJobsFailed(count int) []*Job {
slice := make([]*Job, len(c.jobs))
i := 0
for jobName, builds := range c.jobs {
slice[i] = &Job{Name: jobName, Builds: builds}
i++
}
less := func(i, j int) bool { return len(slice[i].Builds) > len(slice[j].Builds) }
sort.SliceStable(slice, less)
if len(sli... | go | {
"resource": ""
} |
q176492 | Title | test | func (c *Cluster) Title() string {
return fmt.Sprintf("Failure cluster [%s...] failed %d builds, %d jobs, and %d tests over %d days",
c.Identifier[0:6],
c.totalBuilds,
c.totalJobs,
c.totalTests,
c.filer.windowDays,
)
} | go | {
"resource": ""
} |
q176493 | Labels | test | func (c *Cluster) Labels() []string {
labels := []string{"kind/flake"}
topTests := make([]string, len(c.Tests))
for i, test := range c.topTestsFailed(len(c.Tests)) {
topTests[i] = test.Name
}
for sig := range c.filer.creator.TestsSIGs(topTests) {
labels = append(labels, "sig/"+sig)
}
return labels
} | go | {
"resource": ""
} |
q176494 | New | test | func New() *Cron {
return &Cron{
cronAgent: cron.New(),
jobs: map[string]*jobStatus{},
logger: logrus.WithField("client", "cron"),
}
} | go | {
"resource": ""
} |
q176495 | QueuedJobs | test | func (c *Cron) QueuedJobs() []string {
c.lock.Lock()
defer c.lock.Unlock()
res := []string{}
for k, v := range c.jobs {
if v.triggered {
res = append(res, k)
}
c.jobs[k].triggered = false
}
return res
} | go | {
"resource": ""
} |
q176496 | HasJob | test | func (c *Cron) HasJob(name string) bool {
c.lock.Lock()
defer c.lock.Unlock()
_, ok := c.jobs[name]
return ok
} | go | {
"resource": ""
} |
q176497 | addJob | test | func (c *Cron) addJob(name, cron string) error {
id, err := c.cronAgent.AddFunc("TZ=UTC "+cron, func() {
c.lock.Lock()
defer c.lock.Unlock()
c.jobs[name].triggered = true
c.logger.Infof("Triggering cron job %s.", name)
})
if err != nil {
return fmt.Errorf("cronAgent fails to add job %s with cron %s: %v",... | go | {
"resource": ""
} |
q176498 | removeJob | test | func (c *Cron) removeJob(name string) error {
job, ok := c.jobs[name]
if !ok {
return fmt.Errorf("job %s has not been added to cronAgent yet", name)
}
c.cronAgent.Remove(job.entryID)
delete(c.jobs, name)
c.logger.Infof("Removed previous cron job %s.", name)
return nil
} | go | {
"resource": ""
} |
q176499 | UpdateComments | test | func UpdateComments(issueID int, pullRequest bool, db *gorm.DB, client ClientInterface) {
latest := findLatestCommentUpdate(issueID, db, client.RepositoryName())
updateIssueComments(issueID, latest, db, client)
if pullRequest {
updatePullComments(issueID, latest, db, client)
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.