_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q176000 | GetDiskUsage | test | func GetDiskUsage(path string) (percentBlocksFree float64, bytesFree, bytesUsed uint64, err error) {
var stat syscall.Statfs_t
err = syscall.Statfs(path, &stat)
if err != nil {
return 0, 0, 0, err
}
percentBlocksFree = float64(stat.Bfree) / float64(stat.Blocks) * 100
bytesFree = stat.Bfree * uint64(stat.Bsize)
... | go | {
"resource": ""
} |
q176001 | GetATime | test | func GetATime(path string, defaultTime time.Time) time.Time {
at, err := atime.Stat(path)
if err != nil {
log.WithError(err).Errorf("Could not get atime for %s", path)
return defaultTime
}
return at
} | go | {
"resource": ""
} |
q176002 | RegisterLens | test | func RegisterLens(lens Lens) error {
config := lens.Config()
_, ok := lensReg[config.Name]
if ok {
return fmt.Errorf("viewer already registered with name %s", config.Name)
}
if config.Title == "" {
return errors.New("empty title field in view metadata")
}
if config.Priority < 0 {
return errors.New("priori... | go | {
"resource": ""
} |
q176003 | GetLens | test | func GetLens(name string) (Lens, error) {
lens, ok := lensReg[name]
if !ok {
return nil, ErrInvalidLensName
}
return lens, nil
} | go | {
"resource": ""
} |
q176004 | LastNLines | test | func LastNLines(a Artifact, n int64) ([]string, error) {
// 300B, a reasonable log line length, probably a bit more scalable than a hard-coded value
return LastNLinesChunked(a, n, 300*n+1)
} | go | {
"resource": ""
} |
q176005 | NewClient | test | func NewClient(tokenGenerator func() []byte) *Client {
return &Client{
logger: logrus.WithField("client", "slack"),
tokenGenerator: tokenGenerator,
}
} | go | {
"resource": ""
} |
q176006 | WriteMessage | test | func (sl *Client) WriteMessage(text, channel string) error {
sl.log("WriteMessage", text, channel)
if sl.fake {
return nil
}
var uv = sl.urlValues()
uv.Add("channel", channel)
uv.Add("text", text)
_, err := sl.postMessage(chatPostMessage, uv)
return err
} | go | {
"resource": ""
} |
q176007 | MarkAndSweep | test | func (NATGateway) MarkAndSweep(sess *session.Session, acct string, region string, set *Set) error {
svc := ec2.New(sess, &aws.Config{Region: aws.String(region)})
inp := &ec2.DescribeNatGatewaysInput{}
if err := svc.DescribeNatGatewaysPages(inp, func(page *ec2.DescribeNatGatewaysOutput, _ bool) bool {
for _, gw :=... | go | {
"resource": ""
} |
q176008 | ListAll | test | func (NATGateway) ListAll(sess *session.Session, acct, region string) (*Set, error) {
svc := ec2.New(sess, &aws.Config{Region: aws.String(region)})
set := NewSet(0)
inp := &ec2.DescribeNatGatewaysInput{}
err := svc.DescribeNatGatewaysPages(inp, func(page *ec2.DescribeNatGatewaysOutput, _ bool) bool {
for _, gw :... | go | {
"resource": ""
} |
q176009 | NewClient | test | func NewClient(owner string, url string) *Client {
client := &Client{
url: url,
owner: owner,
storage: storage.NewMemoryStorage(),
}
// Configure the dialer to attempt three additional times to establish
// a connection after a failed dial attempt. The dialer should wait 10
// seconds between each at... | go | {
"resource": ""
} |
q176010 | Acquire | test | func (c *Client) Acquire(rtype, state, dest string) (*common.Resource, error) {
r, err := c.acquire(rtype, state, dest)
if err != nil {
return nil, err
}
c.lock.Lock()
defer c.lock.Unlock()
if r != nil {
c.storage.Add(*r)
}
return r, nil
} | go | {
"resource": ""
} |
q176011 | AcquireWait | test | func (c *Client) AcquireWait(ctx context.Context, rtype, state, dest string) (*common.Resource, error) {
if ctx == nil {
return nil, ErrContextRequired
}
// Try to acquire the resource until available or the context is
// cancelled or its deadline exceeded.
for {
r, err := c.Acquire(rtype, state, dest)
if er... | go | {
"resource": ""
} |
q176012 | AcquireByState | test | func (c *Client) AcquireByState(state, dest string, names []string) ([]common.Resource, error) {
resources, err := c.acquireByState(state, dest, names)
if err != nil {
return nil, err
}
c.lock.Lock()
defer c.lock.Unlock()
for _, r := range resources {
c.storage.Add(r)
}
return resources, nil
} | go | {
"resource": ""
} |
q176013 | ReleaseAll | test | func (c *Client) ReleaseAll(dest string) error {
c.lock.Lock()
defer c.lock.Unlock()
resources, err := c.storage.List()
if err != nil {
return err
}
if len(resources) == 0 {
return fmt.Errorf("no holding resource")
}
var allErrors error
for _, r := range resources {
c.storage.Delete(r.GetName())
err :=... | go | {
"resource": ""
} |
q176014 | ReleaseOne | test | func (c *Client) ReleaseOne(name, dest string) error {
c.lock.Lock()
defer c.lock.Unlock()
if _, err := c.storage.Get(name); err != nil {
return fmt.Errorf("no resource name %v", name)
}
c.storage.Delete(name)
if err := c.release(name, dest); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176015 | UpdateAll | test | func (c *Client) UpdateAll(state string) error {
c.lock.Lock()
defer c.lock.Unlock()
resources, err := c.storage.List()
if err != nil {
return err
}
if len(resources) == 0 {
return fmt.Errorf("no holding resource")
}
var allErrors error
for _, r := range resources {
if err := c.update(r.GetName(), state... | go | {
"resource": ""
} |
q176016 | SyncAll | test | func (c *Client) SyncAll() error {
c.lock.Lock()
defer c.lock.Unlock()
resources, err := c.storage.List()
if err != nil {
return err
}
if len(resources) == 0 {
logrus.Info("no resource to sync")
return nil
}
var allErrors error
for _, i := range resources {
r, err := common.ItemToResource(i)
if err ... | go | {
"resource": ""
} |
q176017 | UpdateOne | test | func (c *Client) UpdateOne(name, state string, userData *common.UserData) error {
c.lock.Lock()
defer c.lock.Unlock()
r, err := c.storage.Get(name)
if err != nil {
return fmt.Errorf("no resource name %v", name)
}
if err := c.update(r.GetName(), state, userData); err != nil {
return err
}
return c.updateLoc... | go | {
"resource": ""
} |
q176018 | Metric | test | func (c *Client) Metric(rtype string) (common.Metric, error) {
return c.metric(rtype)
} | go | {
"resource": ""
} |
q176019 | HasResource | test | func (c *Client) HasResource() bool {
resources, _ := c.storage.List()
return len(resources) > 0
} | go | {
"resource": ""
} |
q176020 | DialContext | test | func (d *DialerWithRetry) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
// Always bump the retry count by 1 in order to equal the actual number of
// attempts. For example, if a retry count of 2 is specified, the intent
// is for three attempts -- the initial attempt with two retries ... | go | {
"resource": ""
} |
q176021 | NewDashboardAgent | test | func NewDashboardAgent(repos []string, config *config.GitHubOAuthConfig, log *logrus.Entry) *DashboardAgent {
return &DashboardAgent{
repos: repos,
goac: config,
log: log,
}
} | go | {
"resource": ""
} |
q176022 | QueryPullRequests | test | func (da *DashboardAgent) QueryPullRequests(ctx context.Context, ghc githubClient, query string) ([]PullRequest, error) {
var prs []PullRequest
vars := map[string]interface{}{
"query": (githubql.String)(query),
"searchCursor": (*githubql.String)(nil),
}
var totalCost int
var remaining int
for {
sq :=... | go | {
"resource": ""
} |
q176023 | GetHeadContexts | test | func (da *DashboardAgent) GetHeadContexts(ghc githubClient, pr PullRequest) ([]Context, error) {
org := string(pr.Repository.Owner.Login)
repo := string(pr.Repository.Name)
combined, err := ghc.GetCombinedStatus(org, repo, string(pr.HeadRefOID))
if err != nil {
return nil, fmt.Errorf("failed to get the combined s... | go | {
"resource": ""
} |
q176024 | ConstructSearchQuery | test | func (da *DashboardAgent) ConstructSearchQuery(login string) string {
tokens := []string{"is:pr", "state:open", "author:" + login}
for i := range da.repos {
tokens = append(tokens, fmt.Sprintf("repo:\"%s\"", da.repos[i]))
}
return strings.Join(tokens, " ")
} | go | {
"resource": ""
} |
q176025 | NewBundledStates | test | func NewBundledStates(description string) BundledStates {
return BundledStates{
description: description,
states: map[string]State{},
}
} | go | {
"resource": ""
} |
q176026 | ReceiveEvent | test | func (b BundledStates) ReceiveEvent(ID string, eventName, label string, t time.Time) bool {
state, ok := b.states[ID]
if !ok {
state = NewState(b.description)
}
state, changed := state.ReceiveEvent(eventName, label, t)
b.states[ID] = state
return changed
} | go | {
"resource": ""
} |
q176027 | ages | test | func (b BundledStates) ages(t time.Time) map[string]time.Duration {
ages := map[string]time.Duration{}
for id, state := range b.states {
if !state.Active() {
continue
}
ages[id] = state.Age(t)
}
return ages
} | go | {
"resource": ""
} |
q176028 | Percentile | test | func (b BundledStates) Percentile(t time.Time, percentile int) time.Duration {
if percentile > 100 || percentile <= 0 {
panic(fmt.Errorf("percentile %d is out of scope", percentile))
}
ages := []time.Duration{}
for _, age := range b.ages(t) {
ages = append(ages, age)
}
if len(ages) == 0 {
return 0
}
so... | go | {
"resource": ""
} |
q176029 | NewMetrics | test | func NewMetrics() *Metrics {
return &Metrics{
ClientMetrics: &ClientMetrics{
Requests: requests,
RequestRetries: requestRetries,
RequestLatency: requestLatency,
},
ResyncPeriod: resyncPeriod,
}
} | go | {
"resource": ""
} |
q176030 | NewDiskCache | test | func NewDiskCache(delegate http.RoundTripper, cacheDir string, cacheSizeGB, maxConcurrency int) http.RoundTripper {
return NewFromCache(delegate, diskcache.NewWithDiskv(
diskv.New(diskv.Options{
BasePath: path.Join(cacheDir, "data"),
TempDir: path.Join(cacheDir, "temp"),
CacheSizeMax: uint64(cacheS... | go | {
"resource": ""
} |
q176031 | NewMemCache | test | func NewMemCache(delegate http.RoundTripper, maxConcurrency int) http.RoundTripper {
return NewFromCache(delegate, httpcache.NewMemoryCache(), maxConcurrency)
} | go | {
"resource": ""
} |
q176032 | NewFromCache | test | func NewFromCache(delegate http.RoundTripper, cache httpcache.Cache, maxConcurrency int) http.RoundTripper {
cacheTransport := httpcache.NewTransport(cache)
cacheTransport.Transport = newThrottlingTransport(maxConcurrency, upstreamTransport{delegate: delegate})
return &requestCoalescer{
keys: make(map[string]*... | go | {
"resource": ""
} |
q176033 | ProwV1 | test | func (c *Clientset) ProwV1() prowv1.ProwV1Interface {
return &fakeprowv1.FakeProwV1{Fake: &c.Fake}
} | go | {
"resource": ""
} |
q176034 | Prow | test | func (c *Clientset) Prow() prowv1.ProwV1Interface {
return &fakeprowv1.FakeProwV1{Fake: &c.Fake}
} | go | {
"resource": ""
} |
q176035 | NewOwners | test | func NewOwners(log *logrus.Entry, filenames []string, r Repo, s int64) Owners {
return Owners{filenames: filenames, repo: r, seed: s, log: log}
} | go | {
"resource": ""
} |
q176036 | GetApprovers | test | func (o Owners) GetApprovers() map[string]sets.String {
ownersToApprovers := map[string]sets.String{}
for fn := range o.GetOwnersSet() {
ownersToApprovers[fn] = o.repo.Approvers(fn)
}
return ownersToApprovers
} | go | {
"resource": ""
} |
q176037 | GetAllPotentialApprovers | test | func (o Owners) GetAllPotentialApprovers() []string {
approversOnly := []string{}
for _, approverList := range o.GetLeafApprovers() {
for approver := range approverList {
approversOnly = append(approversOnly, approver)
}
}
sort.Strings(approversOnly)
if len(approversOnly) == 0 {
o.log.Debug("No potential ... | go | {
"resource": ""
} |
q176038 | GetReverseMap | test | func (o Owners) GetReverseMap(approvers map[string]sets.String) map[string]sets.String {
approverOwnersfiles := map[string]sets.String{}
for ownersFile, approvers := range approvers {
for approver := range approvers {
if _, ok := approverOwnersfiles[approver]; ok {
approverOwnersfiles[approver].Insert(owners... | go | {
"resource": ""
} |
q176039 | temporaryUnapprovedFiles | test | func (o Owners) temporaryUnapprovedFiles(approvers sets.String) sets.String {
ap := NewApprovers(o)
for approver := range approvers {
ap.AddApprover(approver, "", false)
}
return ap.UnapprovedFiles()
} | go | {
"resource": ""
} |
q176040 | KeepCoveringApprovers | test | func (o Owners) KeepCoveringApprovers(reverseMap map[string]sets.String, knownApprovers sets.String, potentialApprovers []string) sets.String {
if len(potentialApprovers) == 0 {
o.log.Debug("No potential approvers exist to filter for relevance. Does this repo have OWNERS files?")
}
keptApprovers := sets.NewString(... | go | {
"resource": ""
} |
q176041 | GetSuggestedApprovers | test | func (o Owners) GetSuggestedApprovers(reverseMap map[string]sets.String, potentialApprovers []string) sets.String {
ap := NewApprovers(o)
for !ap.RequirementsMet() {
newApprover := findMostCoveringApprover(potentialApprovers, reverseMap, ap.UnapprovedFiles())
if newApprover == "" {
o.log.Warnf("Couldn't find/s... | go | {
"resource": ""
} |
q176042 | GetOwnersSet | test | func (o Owners) GetOwnersSet() sets.String {
owners := sets.NewString()
for _, fn := range o.filenames {
owners.Insert(o.repo.FindApproverOwnersForFile(fn))
}
o.removeSubdirs(owners)
return owners
} | go | {
"resource": ""
} |
q176043 | GetShuffledApprovers | test | func (o Owners) GetShuffledApprovers() []string {
approversList := o.GetAllPotentialApprovers()
order := rand.New(rand.NewSource(o.seed)).Perm(len(approversList))
people := make([]string, 0, len(approversList))
for _, i := range order {
people = append(people, approversList[i])
}
return people
} | go | {
"resource": ""
} |
q176044 | String | test | func (a Approval) String() string {
return fmt.Sprintf(
`*<a href="%s" title="%s">%s</a>*`,
a.Reference,
a.How,
a.Login,
)
} | go | {
"resource": ""
} |
q176045 | IntersectSetsCase | test | func IntersectSetsCase(one, other sets.String) sets.String {
lower := sets.NewString()
for item := range other {
lower.Insert(strings.ToLower(item))
}
intersection := sets.NewString()
for item := range one {
if lower.Has(strings.ToLower(item)) {
intersection.Insert(item)
}
}
return intersection
} | go | {
"resource": ""
} |
q176046 | NewApprovers | test | func NewApprovers(owners Owners) Approvers {
return Approvers{
owners: owners,
approvers: map[string]Approval{},
assignees: sets.NewString(),
ManuallyApproved: func() bool {
return false
},
}
} | go | {
"resource": ""
} |
q176047 | AddLGTMer | test | func (ap *Approvers) AddLGTMer(login, reference string, noIssue bool) {
if ap.shouldNotOverrideApproval(login, noIssue) {
return
}
ap.approvers[strings.ToLower(login)] = Approval{
Login: login,
How: "LGTM",
Reference: reference,
NoIssue: noIssue,
}
} | go | {
"resource": ""
} |
q176048 | RemoveApprover | test | func (ap *Approvers) RemoveApprover(login string) {
delete(ap.approvers, strings.ToLower(login))
} | go | {
"resource": ""
} |
q176049 | AddAssignees | test | func (ap *Approvers) AddAssignees(logins ...string) {
for _, login := range logins {
ap.assignees.Insert(strings.ToLower(login))
}
} | go | {
"resource": ""
} |
q176050 | GetCurrentApproversSetCased | test | func (ap Approvers) GetCurrentApproversSetCased() sets.String {
currentApprovers := sets.NewString()
for _, approval := range ap.approvers {
currentApprovers.Insert(approval.Login)
}
return currentApprovers
} | go | {
"resource": ""
} |
q176051 | GetFilesApprovers | test | func (ap Approvers) GetFilesApprovers() map[string]sets.String {
filesApprovers := map[string]sets.String{}
currentApprovers := ap.GetCurrentApproversSetCased()
for fn, potentialApprovers := range ap.owners.GetApprovers() {
// The order of parameter matters here:
// - currentApprovers is the list of github handl... | go | {
"resource": ""
} |
q176052 | NoIssueApprovers | test | func (ap Approvers) NoIssueApprovers() map[string]Approval {
nia := map[string]Approval{}
reverseMap := ap.owners.GetReverseMap(ap.owners.GetApprovers())
for login, approver := range ap.approvers {
if !approver.NoIssue {
continue
}
if len(reverseMap[login]) == 0 {
continue
}
nia[login] = approver
... | go | {
"resource": ""
} |
q176053 | UnapprovedFiles | test | func (ap Approvers) UnapprovedFiles() sets.String {
unapproved := sets.NewString()
for fn, approvers := range ap.GetFilesApprovers() {
if len(approvers) == 0 {
unapproved.Insert(fn)
}
}
return unapproved
} | go | {
"resource": ""
} |
q176054 | GetFiles | test | func (ap Approvers) GetFiles(baseURL *url.URL, branch string) []File {
allOwnersFiles := []File{}
filesApprovers := ap.GetFilesApprovers()
for _, file := range ap.owners.GetOwnersSet().List() {
if len(filesApprovers[file]) == 0 {
allOwnersFiles = append(allOwnersFiles, UnapprovedFile{
baseURL: baseURL,
... | go | {
"resource": ""
} |
q176055 | IsApproved | test | func (ap Approvers) IsApproved() bool {
reqsMet := ap.RequirementsMet()
if !reqsMet && ap.ManuallyApproved() {
return true
}
return reqsMet
} | go | {
"resource": ""
} |
q176056 | ListApprovals | test | func (ap Approvers) ListApprovals() []Approval {
approvals := []Approval{}
for _, approver := range ap.GetCurrentApproversSet().List() {
approvals = append(approvals, ap.approvers[approver])
}
return approvals
} | go | {
"resource": ""
} |
q176057 | ListNoIssueApprovals | test | func (ap Approvers) ListNoIssueApprovals() []Approval {
approvals := []Approval{}
for _, approver := range ap.GetNoIssueApproversSet().List() {
approvals = append(approvals, ap.approvers[approver])
}
return approvals
} | go | {
"resource": ""
} |
q176058 | GenerateTemplate | test | func GenerateTemplate(templ, name string, data interface{}) (string, error) {
buf := bytes.NewBufferString("")
if messageTempl, err := template.New(name).Parse(templ); err != nil {
return "", fmt.Errorf("failed to parse template for %s: %v", name, err)
} else if err := messageTempl.Execute(buf, data); err != nil {... | go | {
"resource": ""
} |
q176059 | writeTemplate | test | func writeTemplate(templatePath string, outputPath string, data interface{}) error {
// set up template
funcMap := template.FuncMap{
"anchor": func(input string) string {
return strings.Replace(input, ":", " ", -1)
},
}
t, err := template.New(filepath.Base(templatePath)).Funcs(funcMap).ParseFiles(templatePat... | go | {
"resource": ""
} |
q176060 | Labels | test | func (c Configuration) Labels() []Label {
var labelarrays [][]Label
labelarrays = append(labelarrays, c.Default.Labels)
for _, repo := range c.Repos {
labelarrays = append(labelarrays, repo.Labels)
}
labelmap := make(map[string]Label)
for _, labels := range labelarrays {
for _, l := range labels {
name :=... | go | {
"resource": ""
} |
q176061 | LabelsForTarget | test | func LabelsForTarget(labels []Label, target LabelTarget) (filteredLabels []Label) {
for _, label := range labels {
if target == label.Target {
filteredLabels = append(filteredLabels, label)
}
}
// We also sort to make nice tables
sort.Slice(filteredLabels, func(i, j int) bool { return filteredLabels[i].Name ... | go | {
"resource": ""
} |
q176062 | LoadConfig | test | func LoadConfig(path string, orgs string) (*Configuration, error) {
if path == "" {
return nil, errors.New("empty path")
}
var c Configuration
data, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
if err = yaml.Unmarshal(data, &c); err != nil {
return nil, err
}
if err = c.validate(orgs); ... | go | {
"resource": ""
} |
q176063 | loadLabels | test | func loadLabels(gc client, org string, repos []string) (*RepoLabels, error) {
repoChan := make(chan string, len(repos))
for _, repo := range repos {
repoChan <- repo
}
close(repoChan)
wg := sync.WaitGroup{}
wg.Add(maxConcurrentWorkers)
labels := make(chan RepoLabels, len(repos))
errChan := make(chan error, l... | go | {
"resource": ""
} |
q176064 | kill | test | func kill(repo string, label Label) Update {
logrus.WithField("repo", repo).WithField("label", label.Name).Info("kill")
return Update{Why: "dead", Current: &label, repo: repo}
} | go | {
"resource": ""
} |
q176065 | create | test | func create(repo string, label Label) Update {
logrus.WithField("repo", repo).WithField("label", label.Name).Info("create")
return Update{Why: "missing", Wanted: &label, repo: repo}
} | go | {
"resource": ""
} |
q176066 | classifyLabels | test | func classifyLabels(labels []Label, required, archaic, dead map[string]Label, now time.Time, parent *Label) (map[string]Label, map[string]Label, map[string]Label) {
newRequired := copyLabelMap(required)
newArchaic := copyLabelMap(archaic)
newDead := copyLabelMap(dead)
for i, l := range labels {
first := parent
... | go | {
"resource": ""
} |
q176067 | linkify | test | func linkify(text string) string {
// swap space with dash
link := strings.Replace(text, " ", "-", -1)
// discard some special characters
discard, _ := regexp.Compile("[,/]")
link = discard.ReplaceAllString(link, "")
// lowercase
return strings.ToLower(link)
} | go | {
"resource": ""
} |
q176068 | NewCache | test | func NewCache(diskRoot string) *Cache {
return &Cache{
diskRoot: strings.TrimSuffix(diskRoot, string(os.PathListSeparator)),
}
} | go | {
"resource": ""
} |
q176069 | KeyToPath | test | func (c *Cache) KeyToPath(key string) string {
return filepath.Join(c.diskRoot, key)
} | go | {
"resource": ""
} |
q176070 | ensureDir | test | func ensureDir(dir string) error {
if exists(dir) {
return nil
}
return os.MkdirAll(dir, os.FileMode(0744))
} | go | {
"resource": ""
} |
q176071 | Put | test | func (c *Cache) Put(key string, content io.Reader, contentSHA256 string) error {
// make sure directory exists
path := c.KeyToPath(key)
dir := filepath.Dir(path)
err := ensureDir(dir)
if err != nil {
logrus.WithError(err).Errorf("error ensuring directory '%s' exists", dir)
}
// create a temp file to get the c... | go | {
"resource": ""
} |
q176072 | Get | test | func (c *Cache) Get(key string, readHandler ReadHandler) error {
path := c.KeyToPath(key)
f, err := os.Open(path)
if err != nil {
if os.IsNotExist(err) {
return readHandler(false, nil)
}
return fmt.Errorf("failed to get key: %v", err)
}
return readHandler(true, f)
} | go | {
"resource": ""
} |
q176073 | Delete | test | func (c *Cache) Delete(key string) error {
return os.Remove(c.KeyToPath(key))
} | go | {
"resource": ""
} |
q176074 | NewGCSArtifact | test | func NewGCSArtifact(ctx context.Context, handle artifactHandle, link string, path string, sizeLimit int64) *GCSArtifact {
return &GCSArtifact{
handle: handle,
link: link,
path: path,
sizeLimit: sizeLimit,
ctx: ctx,
}
} | go | {
"resource": ""
} |
q176075 | Size | test | func (a *GCSArtifact) Size() (int64, error) {
attrs, err := a.handle.Attrs(a.ctx)
if err != nil {
return 0, fmt.Errorf("error getting gcs attributes for artifact: %v", err)
}
return attrs.Size, nil
} | go | {
"resource": ""
} |
q176076 | ReadAll | test | func (a *GCSArtifact) ReadAll() ([]byte, error) {
size, err := a.Size()
if err != nil {
return nil, fmt.Errorf("error getting artifact size: %v", err)
}
if size > a.sizeLimit {
return nil, lenses.ErrFileTooLarge
}
reader, err := a.handle.NewReader(a.ctx)
if err != nil {
return nil, fmt.Errorf("error gettin... | go | {
"resource": ""
} |
q176077 | ReadTail | test | func (a *GCSArtifact) ReadTail(n int64) ([]byte, error) {
gzipped, err := a.gzipped()
if err != nil {
return nil, fmt.Errorf("error checking artifact for gzip compression: %v", err)
}
if gzipped {
return nil, lenses.ErrGzipOffsetRead
}
size, err := a.Size()
if err != nil {
return nil, fmt.Errorf("error get... | go | {
"resource": ""
} |
q176078 | gzipped | test | func (a *GCSArtifact) gzipped() (bool, error) {
attrs, err := a.handle.Attrs(a.ctx)
if err != nil {
return false, fmt.Errorf("error getting gcs attributes for artifact: %v", err)
}
return attrs.ContentEncoding == "gzip", nil
} | go | {
"resource": ""
} |
q176079 | optionsForRepo | test | func optionsForRepo(config *plugins.Configuration, org, repo string) *plugins.Welcome {
fullName := fmt.Sprintf("%s/%s", org, repo)
// First search for repo config
for _, c := range config.Welcome {
if !strInSlice(fullName, c.Repos) {
continue
}
return &c
}
// If you don't find anything, loop again look... | go | {
"resource": ""
} |
q176080 | List | test | func (s *prowJobLister) List(selector labels.Selector) (ret []*v1.ProwJob, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1.ProwJob))
})
return ret, err
} | go | {
"resource": ""
} |
q176081 | ProwJobs | test | func (s *prowJobLister) ProwJobs(namespace string) ProwJobNamespaceLister {
return prowJobNamespaceLister{indexer: s.indexer, namespace: namespace}
} | go | {
"resource": ""
} |
q176082 | List | test | func (s prowJobNamespaceLister) List(selector labels.Selector) (ret []*v1.ProwJob, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v1.ProwJob))
})
return ret, err
} | go | {
"resource": ""
} |
q176083 | RunsAgainstAllBranch | test | func (br Brancher) RunsAgainstAllBranch() bool {
return len(br.SkipBranches) == 0 && len(br.Branches) == 0
} | go | {
"resource": ""
} |
q176084 | Intersects | test | func (br Brancher) Intersects(other Brancher) bool {
if br.RunsAgainstAllBranch() || other.RunsAgainstAllBranch() {
return true
}
if len(br.Branches) > 0 {
baseBranches := sets.NewString(br.Branches...)
if len(other.Branches) > 0 {
otherBranches := sets.NewString(other.Branches...)
if baseBranches.Inters... | go | {
"resource": ""
} |
q176085 | ShouldRun | test | func (cm RegexpChangeMatcher) ShouldRun(changes ChangedFilesProvider) (determined bool, shouldRun bool, err error) {
if cm.CouldRun() {
changeList, err := changes()
if err != nil {
return true, false, err
}
return true, cm.RunsAgainstChanges(changeList), nil
}
return false, false, nil
} | go | {
"resource": ""
} |
q176086 | RunsAgainstChanges | test | func (cm RegexpChangeMatcher) RunsAgainstChanges(changes []string) bool {
for _, change := range changes {
if cm.reChanges.MatchString(change) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q176087 | CouldRun | test | func (ps Postsubmit) CouldRun(baseRef string) bool {
return ps.Brancher.ShouldRun(baseRef)
} | go | {
"resource": ""
} |
q176088 | ShouldRun | test | func (ps Postsubmit) ShouldRun(baseRef string, changes ChangedFilesProvider) (bool, error) {
if !ps.CouldRun(baseRef) {
return false, nil
}
if determined, shouldRun, err := ps.RegexpChangeMatcher.ShouldRun(changes); err != nil {
return false, err
} else if determined {
return shouldRun, nil
}
// Postsubmits... | go | {
"resource": ""
} |
q176089 | CouldRun | test | func (ps Presubmit) CouldRun(baseRef string) bool {
return ps.Brancher.ShouldRun(baseRef)
} | go | {
"resource": ""
} |
q176090 | ShouldRun | test | func (ps Presubmit) ShouldRun(baseRef string, changes ChangedFilesProvider, forced, defaults bool) (bool, error) {
if !ps.CouldRun(baseRef) {
return false, nil
}
if ps.AlwaysRun {
return true, nil
}
if forced {
return true, nil
}
if determined, shouldRun, err := ps.RegexpChangeMatcher.ShouldRun(changes); e... | go | {
"resource": ""
} |
q176091 | GetPresubmit | test | func (c *JobConfig) GetPresubmit(repo, jobName string) *Presubmit {
presubmits := c.AllPresubmits([]string{repo})
for i := range presubmits {
ps := presubmits[i]
if ps.Name == jobName {
return &ps
}
}
return nil
} | go | {
"resource": ""
} |
q176092 | SetPresubmits | test | func (c *JobConfig) SetPresubmits(jobs map[string][]Presubmit) error {
nj := map[string][]Presubmit{}
for k, v := range jobs {
nj[k] = make([]Presubmit, len(v))
copy(nj[k], v)
if err := SetPresubmitRegexes(nj[k]); err != nil {
return err
}
}
c.Presubmits = nj
return nil
} | go | {
"resource": ""
} |
q176093 | SetPostsubmits | test | func (c *JobConfig) SetPostsubmits(jobs map[string][]Postsubmit) error {
nj := map[string][]Postsubmit{}
for k, v := range jobs {
nj[k] = make([]Postsubmit, len(v))
copy(nj[k], v)
if err := SetPostsubmitRegexes(nj[k]); err != nil {
return err
}
}
c.Postsubmits = nj
return nil
} | go | {
"resource": ""
} |
q176094 | AllPresubmits | test | func (c *JobConfig) AllPresubmits(repos []string) []Presubmit {
var res []Presubmit
for repo, v := range c.Presubmits {
if len(repos) == 0 {
res = append(res, v...)
} else {
for _, r := range repos {
if r == repo {
res = append(res, v...)
break
}
}
}
}
return res
} | go | {
"resource": ""
} |
q176095 | AllPostsubmits | test | func (c *JobConfig) AllPostsubmits(repos []string) []Postsubmit {
var res []Postsubmit
for repo, v := range c.Postsubmits {
if len(repos) == 0 {
res = append(res, v...)
} else {
for _, r := range repos {
if r == repo {
res = append(res, v...)
break
}
}
}
}
return res
} | go | {
"resource": ""
} |
q176096 | AllPeriodics | test | func (c *JobConfig) AllPeriodics() []Periodic {
var listPeriodic func(ps []Periodic) []Periodic
listPeriodic = func(ps []Periodic) []Periodic {
var res []Periodic
for _, p := range ps {
res = append(res, p)
}
return res
}
return listPeriodic(c.Periodics)
} | go | {
"resource": ""
} |
q176097 | ClearCompiledRegexes | test | func ClearCompiledRegexes(presubmits []Presubmit) {
for i := range presubmits {
presubmits[i].re = nil
presubmits[i].Brancher.re = nil
presubmits[i].Brancher.reSkip = nil
presubmits[i].RegexpChangeMatcher.reChanges = nil
}
} | go | {
"resource": ""
} |
q176098 | Empty | test | func (s *SimpleConfig) Empty() bool {
return len(s.Approvers) == 0 && len(s.Reviewers) == 0 && len(s.RequiredReviewers) == 0 && len(s.Labels) == 0
} | go | {
"resource": ""
} |
q176099 | NewClient | test | func NewClient(
gc *git.Client,
ghc *github.Client,
mdYAMLEnabled func(org, repo string) bool,
skipCollaborators func(org, repo string) bool,
ownersDirBlacklist func() prowConf.OwnersDirBlacklist,
) *Client {
return &Client{
git: gc,
ghc: ghc,
logger: logrus.WithField("client", "repoowners"),
cache:... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.