id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
8,700 | luci/luci-go | milo/buildsource/buildbot/buildstore/master.go | getLUCIBuilders | func getLUCIBuilders(c context.Context, master string) ([]string, error) {
buildersResponse, err := buildbucket.GetBuilders(c)
if err != nil {
return nil, err
}
var result []string
for _, bucket := range buildersResponse.Buckets {
for _, builder := range bucket.Builders {
if builder.PropertiesJson == "" {
continue
}
var prop struct {
Mastername string `json:"mastername"`
}
if err := json.Unmarshal([]byte(builder.PropertiesJson), &prop); err != nil {
logging.WithError(err).Errorf(c, "processing %s/%s", bucket.Name, builder.Name)
continue
}
if prop.Mastername == master {
result = append(result, builder.Name)
}
}
}
return result, nil
} | go | func getLUCIBuilders(c context.Context, master string) ([]string, error) {
buildersResponse, err := buildbucket.GetBuilders(c)
if err != nil {
return nil, err
}
var result []string
for _, bucket := range buildersResponse.Buckets {
for _, builder := range bucket.Builders {
if builder.PropertiesJson == "" {
continue
}
var prop struct {
Mastername string `json:"mastername"`
}
if err := json.Unmarshal([]byte(builder.PropertiesJson), &prop); err != nil {
logging.WithError(err).Errorf(c, "processing %s/%s", bucket.Name, builder.Name)
continue
}
if prop.Mastername == master {
result = append(result, builder.Name)
}
}
}
return result, nil
} | [
"func",
"getLUCIBuilders",
"(",
"c",
"context",
".",
"Context",
",",
"master",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"buildersResponse",
",",
"err",
":=",
"buildbucket",
".",
"GetBuilders",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"result",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"bucket",
":=",
"range",
"buildersResponse",
".",
"Buckets",
"{",
"for",
"_",
",",
"builder",
":=",
"range",
"bucket",
".",
"Builders",
"{",
"if",
"builder",
".",
"PropertiesJson",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"var",
"prop",
"struct",
"{",
"Mastername",
"string",
"`json:\"mastername\"`",
"\n",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"builder",
".",
"PropertiesJson",
")",
",",
"&",
"prop",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"WithError",
"(",
"err",
")",
".",
"Errorf",
"(",
"c",
",",
"\"",
"\"",
",",
"bucket",
".",
"Name",
",",
"builder",
".",
"Name",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"prop",
".",
"Mastername",
"==",
"master",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"builder",
".",
"Name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // getLUCIBuilders returns all LUCI builders for a given master from Swarmbucket.
// LUCI builders do not have their own concept of "master". Instead, this is
// inferred from the "mastername" property in the property JSON. | [
"getLUCIBuilders",
"returns",
"all",
"LUCI",
"builders",
"for",
"a",
"given",
"master",
"from",
"Swarmbucket",
".",
"LUCI",
"builders",
"do",
"not",
"have",
"their",
"own",
"concept",
"of",
"master",
".",
"Instead",
"this",
"is",
"inferred",
"from",
"the",
"mastername",
"property",
"in",
"the",
"property",
"JSON",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/master.go#L49-L74 |
8,701 | luci/luci-go | milo/buildsource/buildbot/buildstore/master.go | AllMasters | func AllMasters(c context.Context, checkAccess bool) ([]*Master, error) {
const batchSize = int32(500)
masters := make([]*Master, 0, batchSize)
q := datastore.NewQuery(masterKind)
// note: avoid calling isAllowedInternal is checkAccess is false.
// checkAccess is usually false in cron jobs where there is no auth state,
// so isAllowedInternal call would unconditionally log an error.
allowInternal := !checkAccess || isAllowedInternal(c)
err := datastore.RunBatch(c, batchSize, q, func(e *masterEntity) error {
if allowInternal || !e.Internal {
m, err := e.decode(c)
if err != nil {
return err
}
masters = append(masters, m)
}
return nil
})
return masters, err
} | go | func AllMasters(c context.Context, checkAccess bool) ([]*Master, error) {
const batchSize = int32(500)
masters := make([]*Master, 0, batchSize)
q := datastore.NewQuery(masterKind)
// note: avoid calling isAllowedInternal is checkAccess is false.
// checkAccess is usually false in cron jobs where there is no auth state,
// so isAllowedInternal call would unconditionally log an error.
allowInternal := !checkAccess || isAllowedInternal(c)
err := datastore.RunBatch(c, batchSize, q, func(e *masterEntity) error {
if allowInternal || !e.Internal {
m, err := e.decode(c)
if err != nil {
return err
}
masters = append(masters, m)
}
return nil
})
return masters, err
} | [
"func",
"AllMasters",
"(",
"c",
"context",
".",
"Context",
",",
"checkAccess",
"bool",
")",
"(",
"[",
"]",
"*",
"Master",
",",
"error",
")",
"{",
"const",
"batchSize",
"=",
"int32",
"(",
"500",
")",
"\n",
"masters",
":=",
"make",
"(",
"[",
"]",
"*",
"Master",
",",
"0",
",",
"batchSize",
")",
"\n",
"q",
":=",
"datastore",
".",
"NewQuery",
"(",
"masterKind",
")",
"\n\n",
"// note: avoid calling isAllowedInternal is checkAccess is false.",
"// checkAccess is usually false in cron jobs where there is no auth state,",
"// so isAllowedInternal call would unconditionally log an error.",
"allowInternal",
":=",
"!",
"checkAccess",
"||",
"isAllowedInternal",
"(",
"c",
")",
"\n",
"err",
":=",
"datastore",
".",
"RunBatch",
"(",
"c",
",",
"batchSize",
",",
"q",
",",
"func",
"(",
"e",
"*",
"masterEntity",
")",
"error",
"{",
"if",
"allowInternal",
"||",
"!",
"e",
".",
"Internal",
"{",
"m",
",",
"err",
":=",
"e",
".",
"decode",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"masters",
"=",
"append",
"(",
"masters",
",",
"m",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"return",
"masters",
",",
"err",
"\n",
"}"
] | // AllMasters returns all buildbot masters. | [
"AllMasters",
"returns",
"all",
"buildbot",
"masters",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/master.go#L206-L226 |
8,702 | luci/luci-go | milo/buildsource/buildbot/buildstore/master.go | GetPendingCounts | func GetPendingCounts(c context.Context, builders []string) ([]int, error) {
entities := make([]builderEntity, len(builders))
for i, b := range builders {
parts := strings.SplitN(b, "/", 2)
if len(parts) < 2 {
return nil, errors.Reason("builder does not have a slash: %q", b).Err()
}
entities[i].MasterKey = datastore.MakeKey(c, masterKind, parts[0])
entities[i].Name = parts[1]
}
if err := datastore.Get(c, entities); err != nil {
for _, e := range err.(errors.MultiError) {
if e != nil && e != datastore.ErrNoSuchEntity {
return nil, err
}
}
}
counts := make([]int, len(entities))
for i, e := range entities {
counts[i] = e.PendingCount
}
return counts, nil
} | go | func GetPendingCounts(c context.Context, builders []string) ([]int, error) {
entities := make([]builderEntity, len(builders))
for i, b := range builders {
parts := strings.SplitN(b, "/", 2)
if len(parts) < 2 {
return nil, errors.Reason("builder does not have a slash: %q", b).Err()
}
entities[i].MasterKey = datastore.MakeKey(c, masterKind, parts[0])
entities[i].Name = parts[1]
}
if err := datastore.Get(c, entities); err != nil {
for _, e := range err.(errors.MultiError) {
if e != nil && e != datastore.ErrNoSuchEntity {
return nil, err
}
}
}
counts := make([]int, len(entities))
for i, e := range entities {
counts[i] = e.PendingCount
}
return counts, nil
} | [
"func",
"GetPendingCounts",
"(",
"c",
"context",
".",
"Context",
",",
"builders",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"int",
",",
"error",
")",
"{",
"entities",
":=",
"make",
"(",
"[",
"]",
"builderEntity",
",",
"len",
"(",
"builders",
")",
")",
"\n",
"for",
"i",
",",
"b",
":=",
"range",
"builders",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"b",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"<",
"2",
"{",
"return",
"nil",
",",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
",",
"b",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"entities",
"[",
"i",
"]",
".",
"MasterKey",
"=",
"datastore",
".",
"MakeKey",
"(",
"c",
",",
"masterKind",
",",
"parts",
"[",
"0",
"]",
")",
"\n",
"entities",
"[",
"i",
"]",
".",
"Name",
"=",
"parts",
"[",
"1",
"]",
"\n",
"}",
"\n",
"if",
"err",
":=",
"datastore",
".",
"Get",
"(",
"c",
",",
"entities",
")",
";",
"err",
"!=",
"nil",
"{",
"for",
"_",
",",
"e",
":=",
"range",
"err",
".",
"(",
"errors",
".",
"MultiError",
")",
"{",
"if",
"e",
"!=",
"nil",
"&&",
"e",
"!=",
"datastore",
".",
"ErrNoSuchEntity",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"counts",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"len",
"(",
"entities",
")",
")",
"\n",
"for",
"i",
",",
"e",
":=",
"range",
"entities",
"{",
"counts",
"[",
"i",
"]",
"=",
"e",
".",
"PendingCount",
"\n",
"}",
"\n",
"return",
"counts",
",",
"nil",
"\n",
"}"
] | // GetPendingCounts returns numbers of pending builds in builders.
// builders must be a list of slash-separated master, builder names. | [
"GetPendingCounts",
"returns",
"numbers",
"of",
"pending",
"builds",
"in",
"builders",
".",
"builders",
"must",
"be",
"a",
"list",
"of",
"slash",
"-",
"separated",
"master",
"builder",
"names",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/master.go#L230-L253 |
8,703 | luci/luci-go | milo/buildsource/buildbot/buildstore/master.go | PutPendingCount | func PutPendingCount(c context.Context, master, builder string, count int) error {
return datastore.Put(c, &builderEntity{
MasterKey: datastore.MakeKey(c, masterKind, master),
Name: builder,
PendingCount: count,
})
} | go | func PutPendingCount(c context.Context, master, builder string, count int) error {
return datastore.Put(c, &builderEntity{
MasterKey: datastore.MakeKey(c, masterKind, master),
Name: builder,
PendingCount: count,
})
} | [
"func",
"PutPendingCount",
"(",
"c",
"context",
".",
"Context",
",",
"master",
",",
"builder",
"string",
",",
"count",
"int",
")",
"error",
"{",
"return",
"datastore",
".",
"Put",
"(",
"c",
",",
"&",
"builderEntity",
"{",
"MasterKey",
":",
"datastore",
".",
"MakeKey",
"(",
"c",
",",
"masterKind",
",",
"master",
")",
",",
"Name",
":",
"builder",
",",
"PendingCount",
":",
"count",
",",
"}",
")",
"\n",
"}"
] | // PutPendingCount persists number of pending builds to a builder.
// Useful for testing. | [
"PutPendingCount",
"persists",
"number",
"of",
"pending",
"builds",
"to",
"a",
"builder",
".",
"Useful",
"for",
"testing",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/master.go#L257-L263 |
8,704 | luci/luci-go | milo/buildsource/buildbot/buildstore/master.go | SaveMaster | func SaveMaster(c context.Context, master *buildbot.Master,
internal bool, expireCallback ExpireCallback) error {
entity := &masterEntity{
Name: master.Name,
Internal: internal,
Modified: clock.Now(c).UTC(),
}
toPut := []interface{}{entity}
for builderName, builder := range master.Builders {
// Trim out extra info in the "Changes" portion of the pending build state,
// we don't actually need comments, files, and properties
for _, pbs := range builder.PendingBuildStates {
for i := range pbs.Source.Changes {
c := &pbs.Source.Changes[i]
c.Comments = ""
c.Files = nil
c.Properties = nil
}
}
toPut = append(toPut, &builderEntity{
MasterKey: datastore.KeyForObj(c, entity),
Name: builderName,
PendingCount: builder.PendingBuilds,
})
}
publicTag := &masterPublic{Name: master.Name}
if internal {
// do the deletion immediately so that the 'public' bit is removed from
// datastore before any internal details are actually written to datastore.
if err := datastore.Delete(c, publicTag); err != nil && err != datastore.ErrNoSuchEntity {
return err
}
} else {
toPut = append(toPut, publicTag)
}
var err error
entity.Data, err = encode(master)
if err != nil {
return err
}
logging.Debugf(c, "Length of gzipped master data: %d", len(entity.Data))
if len(entity.Data) > maxDataSize {
return errors.Reason("master data is %d bytes, which is more than %d limit", len(entity.Data), maxDataSize).
Tag(TooBigTag).
Err()
}
if err := datastore.Put(c, toPut); err != nil {
return err
}
return cleanUpExpiredBuilds(c, master, expireCallback)
} | go | func SaveMaster(c context.Context, master *buildbot.Master,
internal bool, expireCallback ExpireCallback) error {
entity := &masterEntity{
Name: master.Name,
Internal: internal,
Modified: clock.Now(c).UTC(),
}
toPut := []interface{}{entity}
for builderName, builder := range master.Builders {
// Trim out extra info in the "Changes" portion of the pending build state,
// we don't actually need comments, files, and properties
for _, pbs := range builder.PendingBuildStates {
for i := range pbs.Source.Changes {
c := &pbs.Source.Changes[i]
c.Comments = ""
c.Files = nil
c.Properties = nil
}
}
toPut = append(toPut, &builderEntity{
MasterKey: datastore.KeyForObj(c, entity),
Name: builderName,
PendingCount: builder.PendingBuilds,
})
}
publicTag := &masterPublic{Name: master.Name}
if internal {
// do the deletion immediately so that the 'public' bit is removed from
// datastore before any internal details are actually written to datastore.
if err := datastore.Delete(c, publicTag); err != nil && err != datastore.ErrNoSuchEntity {
return err
}
} else {
toPut = append(toPut, publicTag)
}
var err error
entity.Data, err = encode(master)
if err != nil {
return err
}
logging.Debugf(c, "Length of gzipped master data: %d", len(entity.Data))
if len(entity.Data) > maxDataSize {
return errors.Reason("master data is %d bytes, which is more than %d limit", len(entity.Data), maxDataSize).
Tag(TooBigTag).
Err()
}
if err := datastore.Put(c, toPut); err != nil {
return err
}
return cleanUpExpiredBuilds(c, master, expireCallback)
} | [
"func",
"SaveMaster",
"(",
"c",
"context",
".",
"Context",
",",
"master",
"*",
"buildbot",
".",
"Master",
",",
"internal",
"bool",
",",
"expireCallback",
"ExpireCallback",
")",
"error",
"{",
"entity",
":=",
"&",
"masterEntity",
"{",
"Name",
":",
"master",
".",
"Name",
",",
"Internal",
":",
"internal",
",",
"Modified",
":",
"clock",
".",
"Now",
"(",
"c",
")",
".",
"UTC",
"(",
")",
",",
"}",
"\n",
"toPut",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"entity",
"}",
"\n",
"for",
"builderName",
",",
"builder",
":=",
"range",
"master",
".",
"Builders",
"{",
"// Trim out extra info in the \"Changes\" portion of the pending build state,",
"// we don't actually need comments, files, and properties",
"for",
"_",
",",
"pbs",
":=",
"range",
"builder",
".",
"PendingBuildStates",
"{",
"for",
"i",
":=",
"range",
"pbs",
".",
"Source",
".",
"Changes",
"{",
"c",
":=",
"&",
"pbs",
".",
"Source",
".",
"Changes",
"[",
"i",
"]",
"\n",
"c",
".",
"Comments",
"=",
"\"",
"\"",
"\n",
"c",
".",
"Files",
"=",
"nil",
"\n",
"c",
".",
"Properties",
"=",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"toPut",
"=",
"append",
"(",
"toPut",
",",
"&",
"builderEntity",
"{",
"MasterKey",
":",
"datastore",
".",
"KeyForObj",
"(",
"c",
",",
"entity",
")",
",",
"Name",
":",
"builderName",
",",
"PendingCount",
":",
"builder",
".",
"PendingBuilds",
",",
"}",
")",
"\n",
"}",
"\n",
"publicTag",
":=",
"&",
"masterPublic",
"{",
"Name",
":",
"master",
".",
"Name",
"}",
"\n",
"if",
"internal",
"{",
"// do the deletion immediately so that the 'public' bit is removed from",
"// datastore before any internal details are actually written to datastore.",
"if",
"err",
":=",
"datastore",
".",
"Delete",
"(",
"c",
",",
"publicTag",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"datastore",
".",
"ErrNoSuchEntity",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"toPut",
"=",
"append",
"(",
"toPut",
",",
"publicTag",
")",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"entity",
".",
"Data",
",",
"err",
"=",
"encode",
"(",
"master",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"logging",
".",
"Debugf",
"(",
"c",
",",
"\"",
"\"",
",",
"len",
"(",
"entity",
".",
"Data",
")",
")",
"\n",
"if",
"len",
"(",
"entity",
".",
"Data",
")",
">",
"maxDataSize",
"{",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
",",
"len",
"(",
"entity",
".",
"Data",
")",
",",
"maxDataSize",
")",
".",
"Tag",
"(",
"TooBigTag",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"datastore",
".",
"Put",
"(",
"c",
",",
"toPut",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"cleanUpExpiredBuilds",
"(",
"c",
",",
"master",
",",
"expireCallback",
")",
"\n",
"}"
] | // SaveMaster persists the master in the storage.
//
// Expires all incomplete builds in the datastore associated with this master
// and
// - associated with builders not declared in master.Builders
// - OR or not "current" from this master's perspective and >=20min stale. | [
"SaveMaster",
"persists",
"the",
"master",
"in",
"the",
"storage",
".",
"Expires",
"all",
"incomplete",
"builds",
"in",
"the",
"datastore",
"associated",
"with",
"this",
"master",
"and",
"-",
"associated",
"with",
"builders",
"not",
"declared",
"in",
"master",
".",
"Builders",
"-",
"OR",
"or",
"not",
"current",
"from",
"this",
"master",
"s",
"perspective",
"and",
">",
"=",
"20min",
"stale",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/master.go#L274-L327 |
8,705 | luci/luci-go | milo/buildsource/buildbot/buildstore/master.go | expireBuild | func expireBuild(c context.Context, b *buildbot.Build) error {
if !b.TimeStamp.IsZero() {
b.Times.Finish = b.TimeStamp
} else {
b.Times.Finish.Time = clock.Now(c)
}
b.Finished = true
b.Results = buildbot.Exception
b.Currentstep = nil
b.Text = append(b.Text, "Build expired on Milo")
_, err := SaveBuild(c, b)
return err
} | go | func expireBuild(c context.Context, b *buildbot.Build) error {
if !b.TimeStamp.IsZero() {
b.Times.Finish = b.TimeStamp
} else {
b.Times.Finish.Time = clock.Now(c)
}
b.Finished = true
b.Results = buildbot.Exception
b.Currentstep = nil
b.Text = append(b.Text, "Build expired on Milo")
_, err := SaveBuild(c, b)
return err
} | [
"func",
"expireBuild",
"(",
"c",
"context",
".",
"Context",
",",
"b",
"*",
"buildbot",
".",
"Build",
")",
"error",
"{",
"if",
"!",
"b",
".",
"TimeStamp",
".",
"IsZero",
"(",
")",
"{",
"b",
".",
"Times",
".",
"Finish",
"=",
"b",
".",
"TimeStamp",
"\n",
"}",
"else",
"{",
"b",
".",
"Times",
".",
"Finish",
".",
"Time",
"=",
"clock",
".",
"Now",
"(",
"c",
")",
"\n",
"}",
"\n",
"b",
".",
"Finished",
"=",
"true",
"\n",
"b",
".",
"Results",
"=",
"buildbot",
".",
"Exception",
"\n",
"b",
".",
"Currentstep",
"=",
"nil",
"\n",
"b",
".",
"Text",
"=",
"append",
"(",
"b",
".",
"Text",
",",
"\"",
"\"",
")",
"\n",
"_",
",",
"err",
":=",
"SaveBuild",
"(",
"c",
",",
"b",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // expireBuild marks a build as finished and expired. | [
"expireBuild",
"marks",
"a",
"build",
"as",
"finished",
"and",
"expired",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/master.go#L373-L385 |
8,706 | luci/luci-go | milo/buildsource/buildbot/buildstore/master.go | isAllowedInternal | func isAllowedInternal(c context.Context) bool {
settings := common.GetSettings(c)
if settings.Buildbot.InternalReader == "" {
return false
}
allowed, err := auth.IsMember(c, settings.Buildbot.InternalReader)
if err != nil {
logging.WithError(err).Errorf(c, "IsMember(%q) failed", settings.Buildbot.InternalReader)
allowed = false
}
return allowed
} | go | func isAllowedInternal(c context.Context) bool {
settings := common.GetSettings(c)
if settings.Buildbot.InternalReader == "" {
return false
}
allowed, err := auth.IsMember(c, settings.Buildbot.InternalReader)
if err != nil {
logging.WithError(err).Errorf(c, "IsMember(%q) failed", settings.Buildbot.InternalReader)
allowed = false
}
return allowed
} | [
"func",
"isAllowedInternal",
"(",
"c",
"context",
".",
"Context",
")",
"bool",
"{",
"settings",
":=",
"common",
".",
"GetSettings",
"(",
"c",
")",
"\n",
"if",
"settings",
".",
"Buildbot",
".",
"InternalReader",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"allowed",
",",
"err",
":=",
"auth",
".",
"IsMember",
"(",
"c",
",",
"settings",
".",
"Buildbot",
".",
"InternalReader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"WithError",
"(",
"err",
")",
".",
"Errorf",
"(",
"c",
",",
"\"",
"\"",
",",
"settings",
".",
"Buildbot",
".",
"InternalReader",
")",
"\n",
"allowed",
"=",
"false",
"\n",
"}",
"\n",
"return",
"allowed",
"\n",
"}"
] | // isAllowedInternal returns true if the current user has access to internal
// data. In case of an error, logs it and returns false to prevent from
// sniffing based on internal errors. | [
"isAllowedInternal",
"returns",
"true",
"if",
"the",
"current",
"user",
"has",
"access",
"to",
"internal",
"data",
".",
"In",
"case",
"of",
"an",
"error",
"logs",
"it",
"and",
"returns",
"false",
"to",
"prevent",
"from",
"sniffing",
"based",
"on",
"internal",
"errors",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/master.go#L397-L408 |
8,707 | luci/luci-go | milo/buildsource/buildbot/buildstore/master.go | CanAccessMaster | func CanAccessMaster(c context.Context, name string) error {
if ex, err := datastore.Exists(c, &masterPublic{Name: name}); err == nil && ex.Get(0) {
// It exists => it is public
return nil
}
if isAllowedInternal(c) {
return nil
}
code := grpcutil.NotFoundTag
if auth.CurrentUser(c).Identity == identity.AnonymousIdentity {
code = grpcutil.UnauthenticatedTag
}
// Act like master does not exist.
return errors.Reason("master %q not found", name).Tag(code).Err()
} | go | func CanAccessMaster(c context.Context, name string) error {
if ex, err := datastore.Exists(c, &masterPublic{Name: name}); err == nil && ex.Get(0) {
// It exists => it is public
return nil
}
if isAllowedInternal(c) {
return nil
}
code := grpcutil.NotFoundTag
if auth.CurrentUser(c).Identity == identity.AnonymousIdentity {
code = grpcutil.UnauthenticatedTag
}
// Act like master does not exist.
return errors.Reason("master %q not found", name).Tag(code).Err()
} | [
"func",
"CanAccessMaster",
"(",
"c",
"context",
".",
"Context",
",",
"name",
"string",
")",
"error",
"{",
"if",
"ex",
",",
"err",
":=",
"datastore",
".",
"Exists",
"(",
"c",
",",
"&",
"masterPublic",
"{",
"Name",
":",
"name",
"}",
")",
";",
"err",
"==",
"nil",
"&&",
"ex",
".",
"Get",
"(",
"0",
")",
"{",
"// It exists => it is public",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"isAllowedInternal",
"(",
"c",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"code",
":=",
"grpcutil",
".",
"NotFoundTag",
"\n",
"if",
"auth",
".",
"CurrentUser",
"(",
"c",
")",
".",
"Identity",
"==",
"identity",
".",
"AnonymousIdentity",
"{",
"code",
"=",
"grpcutil",
".",
"UnauthenticatedTag",
"\n",
"}",
"\n",
"// Act like master does not exist.",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
",",
"name",
")",
".",
"Tag",
"(",
"code",
")",
".",
"Err",
"(",
")",
"\n",
"}"
] | // CanAccessMaster returns nil if the currently logged in user can see the
// masters, or if the given master is a known public master,
// otherwise an error. | [
"CanAccessMaster",
"returns",
"nil",
"if",
"the",
"currently",
"logged",
"in",
"user",
"can",
"see",
"the",
"masters",
"or",
"if",
"the",
"given",
"master",
"is",
"a",
"known",
"public",
"master",
"otherwise",
"an",
"error",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/master.go#L413-L429 |
8,708 | luci/luci-go | cipd/client/cipd/internal/checksum.go | MarshalWithSHA256 | func MarshalWithSHA256(pm proto.Message) ([]byte, error) {
blob, err := proto.Marshal(pm)
if err != nil {
return nil, err
}
sum := sha256.Sum256(blob)
envelope := messages.BlobWithSHA256{Blob: blob, Sha256: sum[:]}
return proto.Marshal(&envelope)
} | go | func MarshalWithSHA256(pm proto.Message) ([]byte, error) {
blob, err := proto.Marshal(pm)
if err != nil {
return nil, err
}
sum := sha256.Sum256(blob)
envelope := messages.BlobWithSHA256{Blob: blob, Sha256: sum[:]}
return proto.Marshal(&envelope)
} | [
"func",
"MarshalWithSHA256",
"(",
"pm",
"proto",
".",
"Message",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"blob",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"pm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"sum",
":=",
"sha256",
".",
"Sum256",
"(",
"blob",
")",
"\n",
"envelope",
":=",
"messages",
".",
"BlobWithSHA256",
"{",
"Blob",
":",
"blob",
",",
"Sha256",
":",
"sum",
"[",
":",
"]",
"}",
"\n",
"return",
"proto",
".",
"Marshal",
"(",
"&",
"envelope",
")",
"\n",
"}"
] | // MarshalWithSHA256 serializes proto message to bytes, calculates SHA256
// checksum of it, and returns serialized envelope that contains both.
//
// UnmarshalWithSHA256 can then be used to verify SHA256 and deserialized the
// original object. | [
"MarshalWithSHA256",
"serializes",
"proto",
"message",
"to",
"bytes",
"calculates",
"SHA256",
"checksum",
"of",
"it",
"and",
"returns",
"serialized",
"envelope",
"that",
"contains",
"both",
".",
"UnmarshalWithSHA256",
"can",
"then",
"be",
"used",
"to",
"verify",
"SHA256",
"and",
"deserialized",
"the",
"original",
"object",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/cipd/client/cipd/internal/checksum.go#L37-L45 |
8,709 | luci/luci-go | cipd/client/cipd/internal/checksum.go | UnmarshalWithSHA256 | func UnmarshalWithSHA256(buf []byte, pm proto.Message) error {
envelope := messages.BlobWithSHA256{}
if err := proto.Unmarshal(buf, &envelope); err != nil {
return err
}
if len(envelope.Sha256) == 0 {
return ErrUnknownSHA256
}
sum := sha256.Sum256(envelope.Blob)
if !bytes.Equal(sum[:], envelope.Sha256) {
return errors.New("sha256 of the file is invalid, it is probably corrupted")
}
return proto.Unmarshal(envelope.Blob, pm)
} | go | func UnmarshalWithSHA256(buf []byte, pm proto.Message) error {
envelope := messages.BlobWithSHA256{}
if err := proto.Unmarshal(buf, &envelope); err != nil {
return err
}
if len(envelope.Sha256) == 0 {
return ErrUnknownSHA256
}
sum := sha256.Sum256(envelope.Blob)
if !bytes.Equal(sum[:], envelope.Sha256) {
return errors.New("sha256 of the file is invalid, it is probably corrupted")
}
return proto.Unmarshal(envelope.Blob, pm)
} | [
"func",
"UnmarshalWithSHA256",
"(",
"buf",
"[",
"]",
"byte",
",",
"pm",
"proto",
".",
"Message",
")",
"error",
"{",
"envelope",
":=",
"messages",
".",
"BlobWithSHA256",
"{",
"}",
"\n",
"if",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"buf",
",",
"&",
"envelope",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"envelope",
".",
"Sha256",
")",
"==",
"0",
"{",
"return",
"ErrUnknownSHA256",
"\n",
"}",
"\n",
"sum",
":=",
"sha256",
".",
"Sum256",
"(",
"envelope",
".",
"Blob",
")",
"\n",
"if",
"!",
"bytes",
".",
"Equal",
"(",
"sum",
"[",
":",
"]",
",",
"envelope",
".",
"Sha256",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"proto",
".",
"Unmarshal",
"(",
"envelope",
".",
"Blob",
",",
"pm",
")",
"\n",
"}"
] | // UnmarshalWithSHA256 is reverse of MarshalWithSHA256.
//
// It checks SHA256 checksum and deserializes the object if it matches the blob.
//
// If the expected SHA256 is not available in 'buf', returns ErrUnknownSHA256.
// This can happen when reading blobs in old format that used SHA1. | [
"UnmarshalWithSHA256",
"is",
"reverse",
"of",
"MarshalWithSHA256",
".",
"It",
"checks",
"SHA256",
"checksum",
"and",
"deserializes",
"the",
"object",
"if",
"it",
"matches",
"the",
"blob",
".",
"If",
"the",
"expected",
"SHA256",
"is",
"not",
"available",
"in",
"buf",
"returns",
"ErrUnknownSHA256",
".",
"This",
"can",
"happen",
"when",
"reading",
"blobs",
"in",
"old",
"format",
"that",
"used",
"SHA1",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/cipd/client/cipd/internal/checksum.go#L53-L66 |
8,710 | luci/luci-go | logdog/client/cmd/logdog_butler/output.go | AddFactory | func (ocf *outputConfigFlag) AddFactory(f outputFactory) {
ocf.Options = append(ocf.Options, f.option())
} | go | func (ocf *outputConfigFlag) AddFactory(f outputFactory) {
ocf.Options = append(ocf.Options, f.option())
} | [
"func",
"(",
"ocf",
"*",
"outputConfigFlag",
")",
"AddFactory",
"(",
"f",
"outputFactory",
")",
"{",
"ocf",
".",
"Options",
"=",
"append",
"(",
"ocf",
".",
"Options",
",",
"f",
".",
"option",
"(",
")",
")",
"\n",
"}"
] | // Adds an output factory to this outputConfigFlag instance. | [
"Adds",
"an",
"output",
"factory",
"to",
"this",
"outputConfigFlag",
"instance",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/client/cmd/logdog_butler/output.go#L36-L38 |
8,711 | luci/luci-go | logdog/client/cmd/logdog_butler/output.go | getFactory | func (ocf *outputConfigFlag) getFactory() outputFactory {
if ocf.Selected == nil {
return nil
}
if o, ok := ocf.Selected.(*outputOption); ok {
return o.factory
}
return nil
} | go | func (ocf *outputConfigFlag) getFactory() outputFactory {
if ocf.Selected == nil {
return nil
}
if o, ok := ocf.Selected.(*outputOption); ok {
return o.factory
}
return nil
} | [
"func",
"(",
"ocf",
"*",
"outputConfigFlag",
")",
"getFactory",
"(",
")",
"outputFactory",
"{",
"if",
"ocf",
".",
"Selected",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"o",
",",
"ok",
":=",
"ocf",
".",
"Selected",
".",
"(",
"*",
"outputOption",
")",
";",
"ok",
"{",
"return",
"o",
".",
"factory",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Returns the Factory associated with the configured flag. | [
"Returns",
"the",
"Factory",
"associated",
"with",
"the",
"configured",
"flag",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/client/cmd/logdog_butler/output.go#L41-L50 |
8,712 | luci/luci-go | logdog/client/cmd/logdog_butler/output.go | newOutputOption | func newOutputOption(name, description string, f outputFactory) *outputOption {
return &outputOption{
FlagOption: multiflag.FlagOption{
Name: name,
Description: description,
},
factory: f,
}
} | go | func newOutputOption(name, description string, f outputFactory) *outputOption {
return &outputOption{
FlagOption: multiflag.FlagOption{
Name: name,
Description: description,
},
factory: f,
}
} | [
"func",
"newOutputOption",
"(",
"name",
",",
"description",
"string",
",",
"f",
"outputFactory",
")",
"*",
"outputOption",
"{",
"return",
"&",
"outputOption",
"{",
"FlagOption",
":",
"multiflag",
".",
"FlagOption",
"{",
"Name",
":",
"name",
",",
"Description",
":",
"description",
",",
"}",
",",
"factory",
":",
"f",
",",
"}",
"\n",
"}"
] | // newOutputOption instantiates a new outputOption. | [
"newOutputOption",
"instantiates",
"a",
"new",
"outputOption",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/client/cmd/logdog_butler/output.go#L60-L68 |
8,713 | luci/luci-go | tokenserver/appengine/impl/certconfig/rpc_list_cas.go | ListCAs | func (r *ListCAsRPC) ListCAs(c context.Context, _ *empty.Empty) (*admin.ListCAsResponse, error) {
names, err := ListCAs(c)
if err != nil {
return nil, status.Errorf(codes.Internal, "transient datastore error - %s", err)
}
return &admin.ListCAsResponse{Cn: names}, nil
} | go | func (r *ListCAsRPC) ListCAs(c context.Context, _ *empty.Empty) (*admin.ListCAsResponse, error) {
names, err := ListCAs(c)
if err != nil {
return nil, status.Errorf(codes.Internal, "transient datastore error - %s", err)
}
return &admin.ListCAsResponse{Cn: names}, nil
} | [
"func",
"(",
"r",
"*",
"ListCAsRPC",
")",
"ListCAs",
"(",
"c",
"context",
".",
"Context",
",",
"_",
"*",
"empty",
".",
"Empty",
")",
"(",
"*",
"admin",
".",
"ListCAsResponse",
",",
"error",
")",
"{",
"names",
",",
"err",
":=",
"ListCAs",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"admin",
".",
"ListCAsResponse",
"{",
"Cn",
":",
"names",
"}",
",",
"nil",
"\n",
"}"
] | // ListCAs returns a list of Common Names of registered CAs. | [
"ListCAs",
"returns",
"a",
"list",
"of",
"Common",
"Names",
"of",
"registered",
"CAs",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/tokenserver/appengine/impl/certconfig/rpc_list_cas.go#L33-L39 |
8,714 | luci/luci-go | gce/appengine/backend/queues.go | countVMs | func countVMs(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.CountVMs)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
}
// Count VMs per project, server and zone.
// VMs created from the same config eventually have the same project, server,
// and zone but may currently exist for a previous version of the config.
vms := &metrics.InstanceCount{}
// Get the configured count.
cfg := &model.Config{
ID: task.Id,
}
switch err := datastore.Get(c, cfg); {
case err == datastore.ErrNoSuchEntity:
case err != nil:
return errors.Annotate(err, "failed to fetch config").Err()
default:
amt, err := cfg.Config.Amount.GetAmount(clock.Now(c))
if err != nil {
return errors.Annotate(err, "failed to parse amount").Err()
}
vms.AddConfigured(int(amt), cfg.Config.Attributes.Project)
}
// Get the actual (connected, created) counts.
var keys []*datastore.Key
q := datastore.NewQuery(model.VMKind).Eq("config", task.Id)
if err := datastore.GetAll(c, q, &keys); err != nil {
return errors.Annotate(err, "failed to fetch VMs").Err()
}
vm := &model.VM{}
for _, k := range keys {
id := k.StringID()
vm.ID = id
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
default:
if vm.Created > 0 {
vms.AddCreated(1, vm.Attributes.Project, vm.Attributes.Zone)
}
if vm.Connected > 0 {
vms.AddConnected(1, vm.Attributes.Project, vm.Swarming, vm.Attributes.Zone)
}
}
}
if err := vms.Update(c, task.Id); err != nil {
return errors.Annotate(err, "failed to update count").Err()
}
return nil
} | go | func countVMs(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.CountVMs)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
}
// Count VMs per project, server and zone.
// VMs created from the same config eventually have the same project, server,
// and zone but may currently exist for a previous version of the config.
vms := &metrics.InstanceCount{}
// Get the configured count.
cfg := &model.Config{
ID: task.Id,
}
switch err := datastore.Get(c, cfg); {
case err == datastore.ErrNoSuchEntity:
case err != nil:
return errors.Annotate(err, "failed to fetch config").Err()
default:
amt, err := cfg.Config.Amount.GetAmount(clock.Now(c))
if err != nil {
return errors.Annotate(err, "failed to parse amount").Err()
}
vms.AddConfigured(int(amt), cfg.Config.Attributes.Project)
}
// Get the actual (connected, created) counts.
var keys []*datastore.Key
q := datastore.NewQuery(model.VMKind).Eq("config", task.Id)
if err := datastore.GetAll(c, q, &keys); err != nil {
return errors.Annotate(err, "failed to fetch VMs").Err()
}
vm := &model.VM{}
for _, k := range keys {
id := k.StringID()
vm.ID = id
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
default:
if vm.Created > 0 {
vms.AddCreated(1, vm.Attributes.Project, vm.Attributes.Zone)
}
if vm.Connected > 0 {
vms.AddConnected(1, vm.Attributes.Project, vm.Swarming, vm.Attributes.Zone)
}
}
}
if err := vms.Update(c, task.Id); err != nil {
return errors.Annotate(err, "failed to update count").Err()
}
return nil
} | [
"func",
"countVMs",
"(",
"c",
"context",
".",
"Context",
",",
"payload",
"proto",
".",
"Message",
")",
"error",
"{",
"task",
",",
"ok",
":=",
"payload",
".",
"(",
"*",
"tasks",
".",
"CountVMs",
")",
"\n",
"switch",
"{",
"case",
"!",
"ok",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
",",
"payload",
")",
".",
"Err",
"(",
")",
"\n",
"case",
"task",
".",
"GetId",
"(",
")",
"==",
"\"",
"\"",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"// Count VMs per project, server and zone.",
"// VMs created from the same config eventually have the same project, server,",
"// and zone but may currently exist for a previous version of the config.",
"vms",
":=",
"&",
"metrics",
".",
"InstanceCount",
"{",
"}",
"\n\n",
"// Get the configured count.",
"cfg",
":=",
"&",
"model",
".",
"Config",
"{",
"ID",
":",
"task",
".",
"Id",
",",
"}",
"\n",
"switch",
"err",
":=",
"datastore",
".",
"Get",
"(",
"c",
",",
"cfg",
")",
";",
"{",
"case",
"err",
"==",
"datastore",
".",
"ErrNoSuchEntity",
":",
"case",
"err",
"!=",
"nil",
":",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"default",
":",
"amt",
",",
"err",
":=",
"cfg",
".",
"Config",
".",
"Amount",
".",
"GetAmount",
"(",
"clock",
".",
"Now",
"(",
"c",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"vms",
".",
"AddConfigured",
"(",
"int",
"(",
"amt",
")",
",",
"cfg",
".",
"Config",
".",
"Attributes",
".",
"Project",
")",
"\n",
"}",
"\n\n",
"// Get the actual (connected, created) counts.",
"var",
"keys",
"[",
"]",
"*",
"datastore",
".",
"Key",
"\n",
"q",
":=",
"datastore",
".",
"NewQuery",
"(",
"model",
".",
"VMKind",
")",
".",
"Eq",
"(",
"\"",
"\"",
",",
"task",
".",
"Id",
")",
"\n",
"if",
"err",
":=",
"datastore",
".",
"GetAll",
"(",
"c",
",",
"q",
",",
"&",
"keys",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"vm",
":=",
"&",
"model",
".",
"VM",
"{",
"}",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"keys",
"{",
"id",
":=",
"k",
".",
"StringID",
"(",
")",
"\n",
"vm",
".",
"ID",
"=",
"id",
"\n",
"switch",
"err",
":=",
"datastore",
".",
"Get",
"(",
"c",
",",
"vm",
")",
";",
"{",
"case",
"err",
"==",
"datastore",
".",
"ErrNoSuchEntity",
":",
"case",
"err",
"!=",
"nil",
":",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"default",
":",
"if",
"vm",
".",
"Created",
">",
"0",
"{",
"vms",
".",
"AddCreated",
"(",
"1",
",",
"vm",
".",
"Attributes",
".",
"Project",
",",
"vm",
".",
"Attributes",
".",
"Zone",
")",
"\n",
"}",
"\n",
"if",
"vm",
".",
"Connected",
">",
"0",
"{",
"vms",
".",
"AddConnected",
"(",
"1",
",",
"vm",
".",
"Attributes",
".",
"Project",
",",
"vm",
".",
"Swarming",
",",
"vm",
".",
"Attributes",
".",
"Zone",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"vms",
".",
"Update",
"(",
"c",
",",
"task",
".",
"Id",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // countVMs counts the VMs for a given config. | [
"countVMs",
"counts",
"the",
"VMs",
"for",
"a",
"given",
"config",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/gce/appengine/backend/queues.go#L44-L100 |
8,715 | luci/luci-go | gce/appengine/backend/queues.go | drainVM | func drainVM(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.DrainVM)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
}
vm := &model.VM{
ID: task.Id,
}
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
return nil
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
case vm.Drained:
return nil
}
cfg := &model.Config{
ID: vm.Config,
}
switch err := datastore.Get(c, cfg); {
case err == datastore.ErrNoSuchEntity:
// Config doesn't exist, drain the VM.
case err != nil:
return errors.Annotate(err, "failed to fetch config").Err()
}
switch amt, err := cfg.Config.Amount.GetAmount(clock.Now(c)); {
case err != nil:
return errors.Annotate(err, "failed to parse amount").Err()
case amt > vm.Index:
// VM is configured to exist, don't drain the VM.
return nil
}
logging.Debugf(c, "draining VM")
return datastore.RunInTransaction(c, func(c context.Context) error {
// Double-check inside transaction.
// VM may already be drained or deleted.
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
return nil
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
case vm.Drained:
return nil
}
vm.Drained = true
if err := datastore.Put(c, vm); err != nil {
return errors.Annotate(err, "failed to store VM").Err()
}
return nil
}, nil)
} | go | func drainVM(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.DrainVM)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
}
vm := &model.VM{
ID: task.Id,
}
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
return nil
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
case vm.Drained:
return nil
}
cfg := &model.Config{
ID: vm.Config,
}
switch err := datastore.Get(c, cfg); {
case err == datastore.ErrNoSuchEntity:
// Config doesn't exist, drain the VM.
case err != nil:
return errors.Annotate(err, "failed to fetch config").Err()
}
switch amt, err := cfg.Config.Amount.GetAmount(clock.Now(c)); {
case err != nil:
return errors.Annotate(err, "failed to parse amount").Err()
case amt > vm.Index:
// VM is configured to exist, don't drain the VM.
return nil
}
logging.Debugf(c, "draining VM")
return datastore.RunInTransaction(c, func(c context.Context) error {
// Double-check inside transaction.
// VM may already be drained or deleted.
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
return nil
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
case vm.Drained:
return nil
}
vm.Drained = true
if err := datastore.Put(c, vm); err != nil {
return errors.Annotate(err, "failed to store VM").Err()
}
return nil
}, nil)
} | [
"func",
"drainVM",
"(",
"c",
"context",
".",
"Context",
",",
"payload",
"proto",
".",
"Message",
")",
"error",
"{",
"task",
",",
"ok",
":=",
"payload",
".",
"(",
"*",
"tasks",
".",
"DrainVM",
")",
"\n",
"switch",
"{",
"case",
"!",
"ok",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
",",
"payload",
")",
".",
"Err",
"(",
")",
"\n",
"case",
"task",
".",
"GetId",
"(",
")",
"==",
"\"",
"\"",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"vm",
":=",
"&",
"model",
".",
"VM",
"{",
"ID",
":",
"task",
".",
"Id",
",",
"}",
"\n",
"switch",
"err",
":=",
"datastore",
".",
"Get",
"(",
"c",
",",
"vm",
")",
";",
"{",
"case",
"err",
"==",
"datastore",
".",
"ErrNoSuchEntity",
":",
"return",
"nil",
"\n",
"case",
"err",
"!=",
"nil",
":",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"case",
"vm",
".",
"Drained",
":",
"return",
"nil",
"\n",
"}",
"\n",
"cfg",
":=",
"&",
"model",
".",
"Config",
"{",
"ID",
":",
"vm",
".",
"Config",
",",
"}",
"\n",
"switch",
"err",
":=",
"datastore",
".",
"Get",
"(",
"c",
",",
"cfg",
")",
";",
"{",
"case",
"err",
"==",
"datastore",
".",
"ErrNoSuchEntity",
":",
"// Config doesn't exist, drain the VM.",
"case",
"err",
"!=",
"nil",
":",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"switch",
"amt",
",",
"err",
":=",
"cfg",
".",
"Config",
".",
"Amount",
".",
"GetAmount",
"(",
"clock",
".",
"Now",
"(",
"c",
")",
")",
";",
"{",
"case",
"err",
"!=",
"nil",
":",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"case",
"amt",
">",
"vm",
".",
"Index",
":",
"// VM is configured to exist, don't drain the VM.",
"return",
"nil",
"\n",
"}",
"\n",
"logging",
".",
"Debugf",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"return",
"datastore",
".",
"RunInTransaction",
"(",
"c",
",",
"func",
"(",
"c",
"context",
".",
"Context",
")",
"error",
"{",
"// Double-check inside transaction.",
"// VM may already be drained or deleted.",
"switch",
"err",
":=",
"datastore",
".",
"Get",
"(",
"c",
",",
"vm",
")",
";",
"{",
"case",
"err",
"==",
"datastore",
".",
"ErrNoSuchEntity",
":",
"return",
"nil",
"\n",
"case",
"err",
"!=",
"nil",
":",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"case",
"vm",
".",
"Drained",
":",
"return",
"nil",
"\n",
"}",
"\n",
"vm",
".",
"Drained",
"=",
"true",
"\n",
"if",
"err",
":=",
"datastore",
".",
"Put",
"(",
"c",
",",
"vm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
",",
"nil",
")",
"\n",
"}"
] | // drainVM drains a given VM. | [
"drainVM",
"drains",
"a",
"given",
"VM",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/gce/appengine/backend/queues.go#L106-L159 |
8,716 | luci/luci-go | gce/appengine/backend/queues.go | getSuffix | func getSuffix(c context.Context) string {
const allowed = "abcdefghijklmnopqrstuvwxyz0123456789"
suf := make([]byte, 4)
for i := range suf {
suf[i] = allowed[mathrand.Intn(c, len(allowed))]
}
return string(suf)
} | go | func getSuffix(c context.Context) string {
const allowed = "abcdefghijklmnopqrstuvwxyz0123456789"
suf := make([]byte, 4)
for i := range suf {
suf[i] = allowed[mathrand.Intn(c, len(allowed))]
}
return string(suf)
} | [
"func",
"getSuffix",
"(",
"c",
"context",
".",
"Context",
")",
"string",
"{",
"const",
"allowed",
"=",
"\"",
"\"",
"\n",
"suf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"for",
"i",
":=",
"range",
"suf",
"{",
"suf",
"[",
"i",
"]",
"=",
"allowed",
"[",
"mathrand",
".",
"Intn",
"(",
"c",
",",
"len",
"(",
"allowed",
")",
")",
"]",
"\n",
"}",
"\n",
"return",
"string",
"(",
"suf",
")",
"\n",
"}"
] | // getSuffix returns a random suffix to use when naming a GCE instance. | [
"getSuffix",
"returns",
"a",
"random",
"suffix",
"to",
"use",
"when",
"naming",
"a",
"GCE",
"instance",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/gce/appengine/backend/queues.go#L162-L169 |
8,717 | luci/luci-go | gce/appengine/backend/queues.go | createVM | func createVM(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.CreateVM)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
case task.GetConfig() == "":
return errors.Reason("config is required").Err()
}
vm := &model.VM{
ID: task.Id,
Config: task.Config,
Hostname: fmt.Sprintf("%s-%d-%s", task.Prefix, task.Index, getSuffix(c)),
Index: task.Index,
Lifetime: task.Lifetime,
Prefix: task.Prefix,
Revision: task.Revision,
Swarming: task.Swarming,
Timeout: task.Timeout,
}
if task.Attributes != nil {
vm.Attributes = *task.Attributes
// TODO(crbug/942301): Auto-select zone if zone is unspecified.
vm.Attributes.SetZone(vm.Attributes.GetZone())
}
// createVM is called repeatedly, so do a fast check outside the transaction.
// In most cases, this will skip the more expensive transactional check.
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
default:
return nil
}
return datastore.RunInTransaction(c, func(c context.Context) error {
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
default:
return nil
}
if err := datastore.Put(c, vm); err != nil {
return errors.Annotate(err, "failed to store VM").Err()
}
return nil
}, nil)
} | go | func createVM(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.CreateVM)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
case task.GetConfig() == "":
return errors.Reason("config is required").Err()
}
vm := &model.VM{
ID: task.Id,
Config: task.Config,
Hostname: fmt.Sprintf("%s-%d-%s", task.Prefix, task.Index, getSuffix(c)),
Index: task.Index,
Lifetime: task.Lifetime,
Prefix: task.Prefix,
Revision: task.Revision,
Swarming: task.Swarming,
Timeout: task.Timeout,
}
if task.Attributes != nil {
vm.Attributes = *task.Attributes
// TODO(crbug/942301): Auto-select zone if zone is unspecified.
vm.Attributes.SetZone(vm.Attributes.GetZone())
}
// createVM is called repeatedly, so do a fast check outside the transaction.
// In most cases, this will skip the more expensive transactional check.
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
default:
return nil
}
return datastore.RunInTransaction(c, func(c context.Context) error {
switch err := datastore.Get(c, vm); {
case err == datastore.ErrNoSuchEntity:
case err != nil:
return errors.Annotate(err, "failed to fetch VM").Err()
default:
return nil
}
if err := datastore.Put(c, vm); err != nil {
return errors.Annotate(err, "failed to store VM").Err()
}
return nil
}, nil)
} | [
"func",
"createVM",
"(",
"c",
"context",
".",
"Context",
",",
"payload",
"proto",
".",
"Message",
")",
"error",
"{",
"task",
",",
"ok",
":=",
"payload",
".",
"(",
"*",
"tasks",
".",
"CreateVM",
")",
"\n",
"switch",
"{",
"case",
"!",
"ok",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
",",
"payload",
")",
".",
"Err",
"(",
")",
"\n",
"case",
"task",
".",
"GetId",
"(",
")",
"==",
"\"",
"\"",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"case",
"task",
".",
"GetConfig",
"(",
")",
"==",
"\"",
"\"",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"vm",
":=",
"&",
"model",
".",
"VM",
"{",
"ID",
":",
"task",
".",
"Id",
",",
"Config",
":",
"task",
".",
"Config",
",",
"Hostname",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"task",
".",
"Prefix",
",",
"task",
".",
"Index",
",",
"getSuffix",
"(",
"c",
")",
")",
",",
"Index",
":",
"task",
".",
"Index",
",",
"Lifetime",
":",
"task",
".",
"Lifetime",
",",
"Prefix",
":",
"task",
".",
"Prefix",
",",
"Revision",
":",
"task",
".",
"Revision",
",",
"Swarming",
":",
"task",
".",
"Swarming",
",",
"Timeout",
":",
"task",
".",
"Timeout",
",",
"}",
"\n",
"if",
"task",
".",
"Attributes",
"!=",
"nil",
"{",
"vm",
".",
"Attributes",
"=",
"*",
"task",
".",
"Attributes",
"\n",
"// TODO(crbug/942301): Auto-select zone if zone is unspecified.",
"vm",
".",
"Attributes",
".",
"SetZone",
"(",
"vm",
".",
"Attributes",
".",
"GetZone",
"(",
")",
")",
"\n",
"}",
"\n",
"// createVM is called repeatedly, so do a fast check outside the transaction.",
"// In most cases, this will skip the more expensive transactional check.",
"switch",
"err",
":=",
"datastore",
".",
"Get",
"(",
"c",
",",
"vm",
")",
";",
"{",
"case",
"err",
"==",
"datastore",
".",
"ErrNoSuchEntity",
":",
"case",
"err",
"!=",
"nil",
":",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"datastore",
".",
"RunInTransaction",
"(",
"c",
",",
"func",
"(",
"c",
"context",
".",
"Context",
")",
"error",
"{",
"switch",
"err",
":=",
"datastore",
".",
"Get",
"(",
"c",
",",
"vm",
")",
";",
"{",
"case",
"err",
"==",
"datastore",
".",
"ErrNoSuchEntity",
":",
"case",
"err",
"!=",
"nil",
":",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"datastore",
".",
"Put",
"(",
"c",
",",
"vm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
",",
"nil",
")",
"\n",
"}"
] | // createVM creates a VM if it doesn't already exist. | [
"createVM",
"creates",
"a",
"VM",
"if",
"it",
"doesn",
"t",
"already",
"exist",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/gce/appengine/backend/queues.go#L175-L223 |
8,718 | luci/luci-go | gce/appengine/backend/queues.go | expandConfig | func expandConfig(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.ExpandConfig)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
}
cfg, err := getConfig(c).Get(c, &config.GetRequest{Id: task.Id})
if err != nil {
return errors.Annotate(err, "failed to fetch config").Err()
}
now := clock.Now(c)
amt, err := cfg.Amount.GetAmount(now)
if err != nil {
return errors.Annotate(err, "failed to parse amount").Err()
}
t := make([]*tq.Task, amt)
for i := int32(0); i < amt; i++ {
t[i] = &tq.Task{
Payload: &tasks.CreateVM{
Id: fmt.Sprintf("%s-%d", cfg.Prefix, i),
Attributes: cfg.Attributes,
Config: task.Id,
Created: ×tamp.Timestamp{
Seconds: now.Unix(),
},
Index: i,
Lifetime: cfg.Lifetime.GetSeconds(),
Prefix: cfg.Prefix,
Revision: cfg.Revision,
Swarming: cfg.Swarming,
Timeout: cfg.Timeout.GetSeconds(),
},
}
}
logging.Debugf(c, "creating %d VMs", len(t))
if err := getDispatcher(c).AddTask(c, t...); err != nil {
return errors.Annotate(err, "failed to schedule tasks").Err()
}
return nil
} | go | func expandConfig(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.ExpandConfig)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
}
cfg, err := getConfig(c).Get(c, &config.GetRequest{Id: task.Id})
if err != nil {
return errors.Annotate(err, "failed to fetch config").Err()
}
now := clock.Now(c)
amt, err := cfg.Amount.GetAmount(now)
if err != nil {
return errors.Annotate(err, "failed to parse amount").Err()
}
t := make([]*tq.Task, amt)
for i := int32(0); i < amt; i++ {
t[i] = &tq.Task{
Payload: &tasks.CreateVM{
Id: fmt.Sprintf("%s-%d", cfg.Prefix, i),
Attributes: cfg.Attributes,
Config: task.Id,
Created: ×tamp.Timestamp{
Seconds: now.Unix(),
},
Index: i,
Lifetime: cfg.Lifetime.GetSeconds(),
Prefix: cfg.Prefix,
Revision: cfg.Revision,
Swarming: cfg.Swarming,
Timeout: cfg.Timeout.GetSeconds(),
},
}
}
logging.Debugf(c, "creating %d VMs", len(t))
if err := getDispatcher(c).AddTask(c, t...); err != nil {
return errors.Annotate(err, "failed to schedule tasks").Err()
}
return nil
} | [
"func",
"expandConfig",
"(",
"c",
"context",
".",
"Context",
",",
"payload",
"proto",
".",
"Message",
")",
"error",
"{",
"task",
",",
"ok",
":=",
"payload",
".",
"(",
"*",
"tasks",
".",
"ExpandConfig",
")",
"\n",
"switch",
"{",
"case",
"!",
"ok",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
",",
"payload",
")",
".",
"Err",
"(",
")",
"\n",
"case",
"task",
".",
"GetId",
"(",
")",
"==",
"\"",
"\"",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"getConfig",
"(",
"c",
")",
".",
"Get",
"(",
"c",
",",
"&",
"config",
".",
"GetRequest",
"{",
"Id",
":",
"task",
".",
"Id",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"now",
":=",
"clock",
".",
"Now",
"(",
"c",
")",
"\n",
"amt",
",",
"err",
":=",
"cfg",
".",
"Amount",
".",
"GetAmount",
"(",
"now",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"t",
":=",
"make",
"(",
"[",
"]",
"*",
"tq",
".",
"Task",
",",
"amt",
")",
"\n",
"for",
"i",
":=",
"int32",
"(",
"0",
")",
";",
"i",
"<",
"amt",
";",
"i",
"++",
"{",
"t",
"[",
"i",
"]",
"=",
"&",
"tq",
".",
"Task",
"{",
"Payload",
":",
"&",
"tasks",
".",
"CreateVM",
"{",
"Id",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cfg",
".",
"Prefix",
",",
"i",
")",
",",
"Attributes",
":",
"cfg",
".",
"Attributes",
",",
"Config",
":",
"task",
".",
"Id",
",",
"Created",
":",
"&",
"timestamp",
".",
"Timestamp",
"{",
"Seconds",
":",
"now",
".",
"Unix",
"(",
")",
",",
"}",
",",
"Index",
":",
"i",
",",
"Lifetime",
":",
"cfg",
".",
"Lifetime",
".",
"GetSeconds",
"(",
")",
",",
"Prefix",
":",
"cfg",
".",
"Prefix",
",",
"Revision",
":",
"cfg",
".",
"Revision",
",",
"Swarming",
":",
"cfg",
".",
"Swarming",
",",
"Timeout",
":",
"cfg",
".",
"Timeout",
".",
"GetSeconds",
"(",
")",
",",
"}",
",",
"}",
"\n",
"}",
"\n",
"logging",
".",
"Debugf",
"(",
"c",
",",
"\"",
"\"",
",",
"len",
"(",
"t",
")",
")",
"\n",
"if",
"err",
":=",
"getDispatcher",
"(",
"c",
")",
".",
"AddTask",
"(",
"c",
",",
"t",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // expandConfig creates task queue tasks to create each VM in the given config. | [
"expandConfig",
"creates",
"task",
"queue",
"tasks",
"to",
"create",
"each",
"VM",
"in",
"the",
"given",
"config",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/gce/appengine/backend/queues.go#L229-L270 |
8,719 | luci/luci-go | gce/appengine/backend/queues.go | reportQuota | func reportQuota(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.ReportQuota)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
}
p := &model.Project{
ID: task.Id,
}
if err := datastore.Get(c, p); err != nil {
return errors.Annotate(err, "failed to fetch project").Err()
}
mets := stringset.NewFromSlice(p.Config.Metric...)
regs := stringset.NewFromSlice(p.Config.Region...)
rsp, err := getCompute(c).Regions.List(p.Config.Project).Context(c).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok {
logErrors(c, gerr)
return errors.Reason("failed to fetch quota").Err()
}
return errors.Annotate(err, "failed to fetch quota").Err()
}
for _, r := range rsp.Items {
if regs.Has(r.Name) {
for _, q := range r.Quotas {
if mets.Has(q.Metric) {
metrics.UpdateQuota(c, q.Limit, q.Usage, q.Metric, p.Config.Project, r.Name)
}
}
}
}
return nil
} | go | func reportQuota(c context.Context, payload proto.Message) error {
task, ok := payload.(*tasks.ReportQuota)
switch {
case !ok:
return errors.Reason("unexpected payload type %T", payload).Err()
case task.GetId() == "":
return errors.Reason("ID is required").Err()
}
p := &model.Project{
ID: task.Id,
}
if err := datastore.Get(c, p); err != nil {
return errors.Annotate(err, "failed to fetch project").Err()
}
mets := stringset.NewFromSlice(p.Config.Metric...)
regs := stringset.NewFromSlice(p.Config.Region...)
rsp, err := getCompute(c).Regions.List(p.Config.Project).Context(c).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok {
logErrors(c, gerr)
return errors.Reason("failed to fetch quota").Err()
}
return errors.Annotate(err, "failed to fetch quota").Err()
}
for _, r := range rsp.Items {
if regs.Has(r.Name) {
for _, q := range r.Quotas {
if mets.Has(q.Metric) {
metrics.UpdateQuota(c, q.Limit, q.Usage, q.Metric, p.Config.Project, r.Name)
}
}
}
}
return nil
} | [
"func",
"reportQuota",
"(",
"c",
"context",
".",
"Context",
",",
"payload",
"proto",
".",
"Message",
")",
"error",
"{",
"task",
",",
"ok",
":=",
"payload",
".",
"(",
"*",
"tasks",
".",
"ReportQuota",
")",
"\n",
"switch",
"{",
"case",
"!",
"ok",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
",",
"payload",
")",
".",
"Err",
"(",
")",
"\n",
"case",
"task",
".",
"GetId",
"(",
")",
"==",
"\"",
"\"",
":",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"p",
":=",
"&",
"model",
".",
"Project",
"{",
"ID",
":",
"task",
".",
"Id",
",",
"}",
"\n",
"if",
"err",
":=",
"datastore",
".",
"Get",
"(",
"c",
",",
"p",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"mets",
":=",
"stringset",
".",
"NewFromSlice",
"(",
"p",
".",
"Config",
".",
"Metric",
"...",
")",
"\n",
"regs",
":=",
"stringset",
".",
"NewFromSlice",
"(",
"p",
".",
"Config",
".",
"Region",
"...",
")",
"\n",
"rsp",
",",
"err",
":=",
"getCompute",
"(",
"c",
")",
".",
"Regions",
".",
"List",
"(",
"p",
".",
"Config",
".",
"Project",
")",
".",
"Context",
"(",
"c",
")",
".",
"Do",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"gerr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"googleapi",
".",
"Error",
")",
";",
"ok",
"{",
"logErrors",
"(",
"c",
",",
"gerr",
")",
"\n",
"return",
"errors",
".",
"Reason",
"(",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"rsp",
".",
"Items",
"{",
"if",
"regs",
".",
"Has",
"(",
"r",
".",
"Name",
")",
"{",
"for",
"_",
",",
"q",
":=",
"range",
"r",
".",
"Quotas",
"{",
"if",
"mets",
".",
"Has",
"(",
"q",
".",
"Metric",
")",
"{",
"metrics",
".",
"UpdateQuota",
"(",
"c",
",",
"q",
".",
"Limit",
",",
"q",
".",
"Usage",
",",
"q",
".",
"Metric",
",",
"p",
".",
"Config",
".",
"Project",
",",
"r",
".",
"Name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // reportQuota reports GCE quota utilization. | [
"reportQuota",
"reports",
"GCE",
"quota",
"utilization",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/gce/appengine/backend/queues.go#L276-L310 |
8,720 | luci/luci-go | common/isolatedclient/isolatedclient.go | NewBytesSource | func NewBytesSource(d []byte) Source {
return func() (io.ReadCloser, error) {
return ioutil.NopCloser(bytes.NewReader(d)), nil
}
} | go | func NewBytesSource(d []byte) Source {
return func() (io.ReadCloser, error) {
return ioutil.NopCloser(bytes.NewReader(d)), nil
}
} | [
"func",
"NewBytesSource",
"(",
"d",
"[",
"]",
"byte",
")",
"Source",
"{",
"return",
"func",
"(",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"return",
"ioutil",
".",
"NopCloser",
"(",
"bytes",
".",
"NewReader",
"(",
"d",
")",
")",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // NewBytesSource returns a Source implementation that reads from the supplied
// byte slice. | [
"NewBytesSource",
"returns",
"a",
"Source",
"implementation",
"that",
"reads",
"from",
"the",
"supplied",
"byte",
"slice",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/isolatedclient/isolatedclient.go#L46-L50 |
8,721 | luci/luci-go | common/isolatedclient/isolatedclient.go | ServerCapabilities | func (i *Client) ServerCapabilities(c context.Context) (*isolateservice.HandlersEndpointsV1ServerDetails, error) {
out := &isolateservice.HandlersEndpointsV1ServerDetails{}
if err := i.postJSON(c, "/_ah/api/isolateservice/v1/server_details", nil, map[string]string{}, out); err != nil {
return nil, err
}
return out, nil
} | go | func (i *Client) ServerCapabilities(c context.Context) (*isolateservice.HandlersEndpointsV1ServerDetails, error) {
out := &isolateservice.HandlersEndpointsV1ServerDetails{}
if err := i.postJSON(c, "/_ah/api/isolateservice/v1/server_details", nil, map[string]string{}, out); err != nil {
return nil, err
}
return out, nil
} | [
"func",
"(",
"i",
"*",
"Client",
")",
"ServerCapabilities",
"(",
"c",
"context",
".",
"Context",
")",
"(",
"*",
"isolateservice",
".",
"HandlersEndpointsV1ServerDetails",
",",
"error",
")",
"{",
"out",
":=",
"&",
"isolateservice",
".",
"HandlersEndpointsV1ServerDetails",
"{",
"}",
"\n",
"if",
"err",
":=",
"i",
".",
"postJSON",
"(",
"c",
",",
"\"",
"\"",
",",
"nil",
",",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
",",
"out",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // ServerCapabilities returns the server details. | [
"ServerCapabilities",
"returns",
"the",
"server",
"details",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/isolatedclient/isolatedclient.go#L130-L136 |
8,722 | luci/luci-go | common/isolatedclient/isolatedclient.go | Contains | func (i *Client) Contains(c context.Context, items []*isolateservice.HandlersEndpointsV1Digest) (out []*PushState, err error) {
end := tracer.Span(i, "contains", tracer.Args{"number": len(items)})
defer func() { end(tracer.Args{"err": err}) }()
in := isolateservice.HandlersEndpointsV1DigestCollection{Items: items, Namespace: &isolateservice.HandlersEndpointsV1Namespace{}}
in.Namespace.Namespace = i.namespace
data := &isolateservice.HandlersEndpointsV1UrlCollection{}
if err = i.postJSON(c, "/_ah/api/isolateservice/v1/preupload", nil, in, data); err != nil {
return nil, err
}
out = make([]*PushState, len(items))
for _, e := range data.Items {
index := int(e.Index)
out[index] = &PushState{
status: *e,
digest: isolated.HexDigest(items[index].Digest),
size: items[index].Size,
}
}
return out, nil
} | go | func (i *Client) Contains(c context.Context, items []*isolateservice.HandlersEndpointsV1Digest) (out []*PushState, err error) {
end := tracer.Span(i, "contains", tracer.Args{"number": len(items)})
defer func() { end(tracer.Args{"err": err}) }()
in := isolateservice.HandlersEndpointsV1DigestCollection{Items: items, Namespace: &isolateservice.HandlersEndpointsV1Namespace{}}
in.Namespace.Namespace = i.namespace
data := &isolateservice.HandlersEndpointsV1UrlCollection{}
if err = i.postJSON(c, "/_ah/api/isolateservice/v1/preupload", nil, in, data); err != nil {
return nil, err
}
out = make([]*PushState, len(items))
for _, e := range data.Items {
index := int(e.Index)
out[index] = &PushState{
status: *e,
digest: isolated.HexDigest(items[index].Digest),
size: items[index].Size,
}
}
return out, nil
} | [
"func",
"(",
"i",
"*",
"Client",
")",
"Contains",
"(",
"c",
"context",
".",
"Context",
",",
"items",
"[",
"]",
"*",
"isolateservice",
".",
"HandlersEndpointsV1Digest",
")",
"(",
"out",
"[",
"]",
"*",
"PushState",
",",
"err",
"error",
")",
"{",
"end",
":=",
"tracer",
".",
"Span",
"(",
"i",
",",
"\"",
"\"",
",",
"tracer",
".",
"Args",
"{",
"\"",
"\"",
":",
"len",
"(",
"items",
")",
"}",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"end",
"(",
"tracer",
".",
"Args",
"{",
"\"",
"\"",
":",
"err",
"}",
")",
"}",
"(",
")",
"\n",
"in",
":=",
"isolateservice",
".",
"HandlersEndpointsV1DigestCollection",
"{",
"Items",
":",
"items",
",",
"Namespace",
":",
"&",
"isolateservice",
".",
"HandlersEndpointsV1Namespace",
"{",
"}",
"}",
"\n",
"in",
".",
"Namespace",
".",
"Namespace",
"=",
"i",
".",
"namespace",
"\n",
"data",
":=",
"&",
"isolateservice",
".",
"HandlersEndpointsV1UrlCollection",
"{",
"}",
"\n",
"if",
"err",
"=",
"i",
".",
"postJSON",
"(",
"c",
",",
"\"",
"\"",
",",
"nil",
",",
"in",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"out",
"=",
"make",
"(",
"[",
"]",
"*",
"PushState",
",",
"len",
"(",
"items",
")",
")",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"data",
".",
"Items",
"{",
"index",
":=",
"int",
"(",
"e",
".",
"Index",
")",
"\n",
"out",
"[",
"index",
"]",
"=",
"&",
"PushState",
"{",
"status",
":",
"*",
"e",
",",
"digest",
":",
"isolated",
".",
"HexDigest",
"(",
"items",
"[",
"index",
"]",
".",
"Digest",
")",
",",
"size",
":",
"items",
"[",
"index",
"]",
".",
"Size",
",",
"}",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // Contains looks up cache presence on the server of multiple items.
//
// The returned list is in the same order as 'items', with entries nil for
// items that were present. | [
"Contains",
"looks",
"up",
"cache",
"presence",
"on",
"the",
"server",
"of",
"multiple",
"items",
".",
"The",
"returned",
"list",
"is",
"in",
"the",
"same",
"order",
"as",
"items",
"with",
"entries",
"nil",
"for",
"items",
"that",
"were",
"present",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/isolatedclient/isolatedclient.go#L142-L161 |
8,723 | luci/luci-go | common/isolatedclient/isolatedclient.go | Fetch | func (i *Client) Fetch(c context.Context, digest isolated.HexDigest, dest io.Writer) error {
// Perform initial request.
name := ""
switch i.h {
case crypto.SHA1:
name = "sha-1"
case crypto.SHA256:
name = "sha-256"
case crypto.SHA512:
name = "sha-512"
}
url := i.url + "/_ah/api/isolateservice/v1/retrieve"
in := &isolateservice.HandlersEndpointsV1RetrieveRequest{
Digest: string(digest),
Namespace: &isolateservice.HandlersEndpointsV1Namespace{
DigestHash: name,
Namespace: i.namespace,
},
Offset: 0,
}
var out isolateservice.HandlersEndpointsV1RetrievedContent
if _, err := lhttp.PostJSON(c, i.retryFactory, i.authClient, url, nil, in, &out); err != nil {
return err
}
// Handle DB items.
if out.Content != "" {
decoded, err := base64.StdEncoding.DecodeString(out.Content)
if err != nil {
return err
}
decompressor, err := isolated.GetDecompressor(i.namespace, bytes.NewReader(decoded))
if err != nil {
return err
}
defer decompressor.Close()
_, err = io.Copy(dest, decompressor)
return err
}
// Handle GCS items.
return i.gcsHandler.Fetch(c, i, out, dest)
} | go | func (i *Client) Fetch(c context.Context, digest isolated.HexDigest, dest io.Writer) error {
// Perform initial request.
name := ""
switch i.h {
case crypto.SHA1:
name = "sha-1"
case crypto.SHA256:
name = "sha-256"
case crypto.SHA512:
name = "sha-512"
}
url := i.url + "/_ah/api/isolateservice/v1/retrieve"
in := &isolateservice.HandlersEndpointsV1RetrieveRequest{
Digest: string(digest),
Namespace: &isolateservice.HandlersEndpointsV1Namespace{
DigestHash: name,
Namespace: i.namespace,
},
Offset: 0,
}
var out isolateservice.HandlersEndpointsV1RetrievedContent
if _, err := lhttp.PostJSON(c, i.retryFactory, i.authClient, url, nil, in, &out); err != nil {
return err
}
// Handle DB items.
if out.Content != "" {
decoded, err := base64.StdEncoding.DecodeString(out.Content)
if err != nil {
return err
}
decompressor, err := isolated.GetDecompressor(i.namespace, bytes.NewReader(decoded))
if err != nil {
return err
}
defer decompressor.Close()
_, err = io.Copy(dest, decompressor)
return err
}
// Handle GCS items.
return i.gcsHandler.Fetch(c, i, out, dest)
} | [
"func",
"(",
"i",
"*",
"Client",
")",
"Fetch",
"(",
"c",
"context",
".",
"Context",
",",
"digest",
"isolated",
".",
"HexDigest",
",",
"dest",
"io",
".",
"Writer",
")",
"error",
"{",
"// Perform initial request.",
"name",
":=",
"\"",
"\"",
"\n",
"switch",
"i",
".",
"h",
"{",
"case",
"crypto",
".",
"SHA1",
":",
"name",
"=",
"\"",
"\"",
"\n",
"case",
"crypto",
".",
"SHA256",
":",
"name",
"=",
"\"",
"\"",
"\n",
"case",
"crypto",
".",
"SHA512",
":",
"name",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"url",
":=",
"i",
".",
"url",
"+",
"\"",
"\"",
"\n",
"in",
":=",
"&",
"isolateservice",
".",
"HandlersEndpointsV1RetrieveRequest",
"{",
"Digest",
":",
"string",
"(",
"digest",
")",
",",
"Namespace",
":",
"&",
"isolateservice",
".",
"HandlersEndpointsV1Namespace",
"{",
"DigestHash",
":",
"name",
",",
"Namespace",
":",
"i",
".",
"namespace",
",",
"}",
",",
"Offset",
":",
"0",
",",
"}",
"\n",
"var",
"out",
"isolateservice",
".",
"HandlersEndpointsV1RetrievedContent",
"\n",
"if",
"_",
",",
"err",
":=",
"lhttp",
".",
"PostJSON",
"(",
"c",
",",
"i",
".",
"retryFactory",
",",
"i",
".",
"authClient",
",",
"url",
",",
"nil",
",",
"in",
",",
"&",
"out",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Handle DB items.",
"if",
"out",
".",
"Content",
"!=",
"\"",
"\"",
"{",
"decoded",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"out",
".",
"Content",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"decompressor",
",",
"err",
":=",
"isolated",
".",
"GetDecompressor",
"(",
"i",
".",
"namespace",
",",
"bytes",
".",
"NewReader",
"(",
"decoded",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"decompressor",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"dest",
",",
"decompressor",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// Handle GCS items.",
"return",
"i",
".",
"gcsHandler",
".",
"Fetch",
"(",
"c",
",",
"i",
",",
"out",
",",
"dest",
")",
"\n",
"}"
] | // Fetch downloads an item from the server. | [
"Fetch",
"downloads",
"an",
"item",
"from",
"the",
"server",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/isolatedclient/isolatedclient.go#L196-L238 |
8,724 | luci/luci-go | common/isolatedclient/isolatedclient.go | postJSON | func (i *Client) postJSON(c context.Context, resource string, headers map[string]string, in, out interface{}) error {
if len(resource) == 0 || resource[0] != '/' {
return errors.New("resource must start with '/'")
}
_, err := lhttp.PostJSON(c, i.retryFactory, i.authClient, i.url+resource, headers, in, out)
return err
} | go | func (i *Client) postJSON(c context.Context, resource string, headers map[string]string, in, out interface{}) error {
if len(resource) == 0 || resource[0] != '/' {
return errors.New("resource must start with '/'")
}
_, err := lhttp.PostJSON(c, i.retryFactory, i.authClient, i.url+resource, headers, in, out)
return err
} | [
"func",
"(",
"i",
"*",
"Client",
")",
"postJSON",
"(",
"c",
"context",
".",
"Context",
",",
"resource",
"string",
",",
"headers",
"map",
"[",
"string",
"]",
"string",
",",
"in",
",",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"len",
"(",
"resource",
")",
"==",
"0",
"||",
"resource",
"[",
"0",
"]",
"!=",
"'/'",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"lhttp",
".",
"PostJSON",
"(",
"c",
",",
"i",
".",
"retryFactory",
",",
"i",
".",
"authClient",
",",
"i",
".",
"url",
"+",
"resource",
",",
"headers",
",",
"in",
",",
"out",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // postJSON does authenticated POST request. | [
"postJSON",
"does",
"authenticated",
"POST",
"request",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/isolatedclient/isolatedclient.go#L241-L247 |
8,725 | luci/luci-go | common/isolatedclient/isolatedclient.go | Fetch | func (gcs defaultGCSHandler) Fetch(c context.Context, i *Client, content isolateservice.HandlersEndpointsV1RetrievedContent, dest io.Writer) error {
rgen := func() (*http.Request, error) {
return http.NewRequest("GET", content.Url, nil)
}
handler := func(resp *http.Response) error {
defer resp.Body.Close()
decompressor, err := isolated.GetDecompressor(i.namespace, resp.Body)
if err != nil {
return err
}
defer decompressor.Close()
_, err = io.Copy(dest, decompressor)
return err
}
_, err := lhttp.NewRequest(c, i.authClient, i.retryFactory, rgen, handler, nil)()
return err
} | go | func (gcs defaultGCSHandler) Fetch(c context.Context, i *Client, content isolateservice.HandlersEndpointsV1RetrievedContent, dest io.Writer) error {
rgen := func() (*http.Request, error) {
return http.NewRequest("GET", content.Url, nil)
}
handler := func(resp *http.Response) error {
defer resp.Body.Close()
decompressor, err := isolated.GetDecompressor(i.namespace, resp.Body)
if err != nil {
return err
}
defer decompressor.Close()
_, err = io.Copy(dest, decompressor)
return err
}
_, err := lhttp.NewRequest(c, i.authClient, i.retryFactory, rgen, handler, nil)()
return err
} | [
"func",
"(",
"gcs",
"defaultGCSHandler",
")",
"Fetch",
"(",
"c",
"context",
".",
"Context",
",",
"i",
"*",
"Client",
",",
"content",
"isolateservice",
".",
"HandlersEndpointsV1RetrievedContent",
",",
"dest",
"io",
".",
"Writer",
")",
"error",
"{",
"rgen",
":=",
"func",
"(",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"return",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"content",
".",
"Url",
",",
"nil",
")",
"\n",
"}",
"\n",
"handler",
":=",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"decompressor",
",",
"err",
":=",
"isolated",
".",
"GetDecompressor",
"(",
"i",
".",
"namespace",
",",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"decompressor",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"dest",
",",
"decompressor",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"lhttp",
".",
"NewRequest",
"(",
"c",
",",
"i",
".",
"authClient",
",",
"i",
".",
"retryFactory",
",",
"rgen",
",",
"handler",
",",
"nil",
")",
"(",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Fetch uses the provided HandlersEndpointsV1RetrievedContent response to
// download content from GCS to the provided dest. | [
"Fetch",
"uses",
"the",
"provided",
"HandlersEndpointsV1RetrievedContent",
"response",
"to",
"download",
"content",
"from",
"GCS",
"to",
"the",
"provided",
"dest",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/isolatedclient/isolatedclient.go#L296-L312 |
8,726 | luci/luci-go | common/isolatedclient/isolatedclient.go | Push | func (gcs defaultGCSHandler) Push(c context.Context, i *Client, status isolateservice.HandlersEndpointsV1PreuploadStatus, source Source) error {
// GsUploadUrl is signed Google Storage URL that doesn't require additional
// authentication. In fact, using authClient causes HTTP 403 because
// authClient's tokens don't have Cloud Storage OAuth scope. Use anonymous
// client instead.
req := lhttp.NewRequest(c, i.anonClient, i.retryFactory, func() (*http.Request, error) {
src, err := source()
if err != nil {
return nil, err
}
request, err := http.NewRequest("PUT", status.GsUploadUrl, nil)
if err != nil {
src.Close()
return nil, err
}
request.Body = newCompressed(i.namespace, src)
request.Header.Set("Content-Type", "application/octet-stream")
return request, nil
}, func(resp *http.Response) error {
_, err4 := io.Copy(ioutil.Discard, resp.Body)
err5 := resp.Body.Close()
if err4 != nil {
return err4
}
return err5
}, nil)
_, err := req()
return err
} | go | func (gcs defaultGCSHandler) Push(c context.Context, i *Client, status isolateservice.HandlersEndpointsV1PreuploadStatus, source Source) error {
// GsUploadUrl is signed Google Storage URL that doesn't require additional
// authentication. In fact, using authClient causes HTTP 403 because
// authClient's tokens don't have Cloud Storage OAuth scope. Use anonymous
// client instead.
req := lhttp.NewRequest(c, i.anonClient, i.retryFactory, func() (*http.Request, error) {
src, err := source()
if err != nil {
return nil, err
}
request, err := http.NewRequest("PUT", status.GsUploadUrl, nil)
if err != nil {
src.Close()
return nil, err
}
request.Body = newCompressed(i.namespace, src)
request.Header.Set("Content-Type", "application/octet-stream")
return request, nil
}, func(resp *http.Response) error {
_, err4 := io.Copy(ioutil.Discard, resp.Body)
err5 := resp.Body.Close()
if err4 != nil {
return err4
}
return err5
}, nil)
_, err := req()
return err
} | [
"func",
"(",
"gcs",
"defaultGCSHandler",
")",
"Push",
"(",
"c",
"context",
".",
"Context",
",",
"i",
"*",
"Client",
",",
"status",
"isolateservice",
".",
"HandlersEndpointsV1PreuploadStatus",
",",
"source",
"Source",
")",
"error",
"{",
"// GsUploadUrl is signed Google Storage URL that doesn't require additional",
"// authentication. In fact, using authClient causes HTTP 403 because",
"// authClient's tokens don't have Cloud Storage OAuth scope. Use anonymous",
"// client instead.",
"req",
":=",
"lhttp",
".",
"NewRequest",
"(",
"c",
",",
"i",
".",
"anonClient",
",",
"i",
".",
"retryFactory",
",",
"func",
"(",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"src",
",",
"err",
":=",
"source",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"request",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"status",
".",
"GsUploadUrl",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"src",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"request",
".",
"Body",
"=",
"newCompressed",
"(",
"i",
".",
"namespace",
",",
"src",
")",
"\n",
"request",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"request",
",",
"nil",
"\n",
"}",
",",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"_",
",",
"err4",
":=",
"io",
".",
"Copy",
"(",
"ioutil",
".",
"Discard",
",",
"resp",
".",
"Body",
")",
"\n",
"err5",
":=",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"err4",
"!=",
"nil",
"{",
"return",
"err4",
"\n",
"}",
"\n",
"return",
"err5",
"\n",
"}",
",",
"nil",
")",
"\n",
"_",
",",
"err",
":=",
"req",
"(",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Push uploads content from the provided source to the GCS path specified in
// the HandlersEndpointsV1PreuploadStatus response. | [
"Push",
"uploads",
"content",
"from",
"the",
"provided",
"source",
"to",
"the",
"GCS",
"path",
"specified",
"in",
"the",
"HandlersEndpointsV1PreuploadStatus",
"response",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/isolatedclient/isolatedclient.go#L316-L345 |
8,727 | luci/luci-go | luci_notify/config/validate.go | init | func init() {
validation.Rules.Add(
"regex:projects/.*",
"${appid}.cfg",
func(ctx *validation.Context, configSet, path string, content []byte) error {
cfg := ¬ifypb.ProjectConfig{}
if err := proto.UnmarshalText(string(content), cfg); err != nil {
ctx.Errorf("invalid ProjectConfig proto message: %s", err)
} else {
validateProjectConfig(ctx, cfg)
}
return nil
})
validation.Rules.Add(
"regex:projects/.*",
`regex:${appid}/email-templates/[^/]+\.template`,
validateEmailTemplateFile)
} | go | func init() {
validation.Rules.Add(
"regex:projects/.*",
"${appid}.cfg",
func(ctx *validation.Context, configSet, path string, content []byte) error {
cfg := ¬ifypb.ProjectConfig{}
if err := proto.UnmarshalText(string(content), cfg); err != nil {
ctx.Errorf("invalid ProjectConfig proto message: %s", err)
} else {
validateProjectConfig(ctx, cfg)
}
return nil
})
validation.Rules.Add(
"regex:projects/.*",
`regex:${appid}/email-templates/[^/]+\.template`,
validateEmailTemplateFile)
} | [
"func",
"init",
"(",
")",
"{",
"validation",
".",
"Rules",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"func",
"(",
"ctx",
"*",
"validation",
".",
"Context",
",",
"configSet",
",",
"path",
"string",
",",
"content",
"[",
"]",
"byte",
")",
"error",
"{",
"cfg",
":=",
"&",
"notifypb",
".",
"ProjectConfig",
"{",
"}",
"\n",
"if",
"err",
":=",
"proto",
".",
"UnmarshalText",
"(",
"string",
"(",
"content",
")",
",",
"cfg",
")",
";",
"err",
"!=",
"nil",
"{",
"ctx",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"validateProjectConfig",
"(",
"ctx",
",",
"cfg",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n\n",
"validation",
".",
"Rules",
".",
"Add",
"(",
"\"",
"\"",
",",
"`regex:${appid}/email-templates/[^/]+\\.template`",
",",
"validateEmailTemplateFile",
")",
"\n",
"}"
] | // init registers validators for the project config and email template files. | [
"init",
"registers",
"validators",
"for",
"the",
"project",
"config",
"and",
"email",
"template",
"files",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/luci_notify/config/validate.go#L41-L59 |
8,728 | luci/luci-go | luci_notify/config/validate.go | validateNotification | func validateNotification(c *validation.Context, cfgNotification *notifypb.Notification) {
if cfgNotification.Email != nil {
for _, addr := range cfgNotification.Email.Recipients {
if _, err := mail.ParseAddress(addr); err != nil {
c.Errorf(badEmailError, addr)
}
}
}
} | go | func validateNotification(c *validation.Context, cfgNotification *notifypb.Notification) {
if cfgNotification.Email != nil {
for _, addr := range cfgNotification.Email.Recipients {
if _, err := mail.ParseAddress(addr); err != nil {
c.Errorf(badEmailError, addr)
}
}
}
} | [
"func",
"validateNotification",
"(",
"c",
"*",
"validation",
".",
"Context",
",",
"cfgNotification",
"*",
"notifypb",
".",
"Notification",
")",
"{",
"if",
"cfgNotification",
".",
"Email",
"!=",
"nil",
"{",
"for",
"_",
",",
"addr",
":=",
"range",
"cfgNotification",
".",
"Email",
".",
"Recipients",
"{",
"if",
"_",
",",
"err",
":=",
"mail",
".",
"ParseAddress",
"(",
"addr",
")",
";",
"err",
"!=",
"nil",
"{",
"c",
".",
"Errorf",
"(",
"badEmailError",
",",
"addr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // validateNotification is a helper function for validateConfig which validates
// an individual notification configuration. | [
"validateNotification",
"is",
"a",
"helper",
"function",
"for",
"validateConfig",
"which",
"validates",
"an",
"individual",
"notification",
"configuration",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/luci_notify/config/validate.go#L72-L80 |
8,729 | luci/luci-go | luci_notify/config/validate.go | validateBuilder | func validateBuilder(c *validation.Context, cfgBuilder *notifypb.Builder, builderNames stringset.Set) {
if cfgBuilder.Bucket == "" {
c.Errorf(requiredFieldError, "bucket")
}
if strings.HasPrefix(cfgBuilder.Bucket, "luci.") {
// TODO(tandrii): change to warning once our validation library supports it.
c.Errorf(`field "bucket" should not include legacy "luci.<project_name>." prefix, given %q`, cfgBuilder.Bucket)
}
if cfgBuilder.Name == "" {
c.Errorf(requiredFieldError, "name")
}
if cfgBuilder.Repository != "" {
if err := gitiles.ValidateRepoURL(cfgBuilder.Repository); err != nil {
c.Errorf(badRepoURLError, cfgBuilder.Repository)
}
}
fullName := fmt.Sprintf("%s/%s", cfgBuilder.Bucket, cfgBuilder.Name)
if !builderNames.Add(fullName) {
c.Errorf(duplicateBuilderError, fullName)
}
} | go | func validateBuilder(c *validation.Context, cfgBuilder *notifypb.Builder, builderNames stringset.Set) {
if cfgBuilder.Bucket == "" {
c.Errorf(requiredFieldError, "bucket")
}
if strings.HasPrefix(cfgBuilder.Bucket, "luci.") {
// TODO(tandrii): change to warning once our validation library supports it.
c.Errorf(`field "bucket" should not include legacy "luci.<project_name>." prefix, given %q`, cfgBuilder.Bucket)
}
if cfgBuilder.Name == "" {
c.Errorf(requiredFieldError, "name")
}
if cfgBuilder.Repository != "" {
if err := gitiles.ValidateRepoURL(cfgBuilder.Repository); err != nil {
c.Errorf(badRepoURLError, cfgBuilder.Repository)
}
}
fullName := fmt.Sprintf("%s/%s", cfgBuilder.Bucket, cfgBuilder.Name)
if !builderNames.Add(fullName) {
c.Errorf(duplicateBuilderError, fullName)
}
} | [
"func",
"validateBuilder",
"(",
"c",
"*",
"validation",
".",
"Context",
",",
"cfgBuilder",
"*",
"notifypb",
".",
"Builder",
",",
"builderNames",
"stringset",
".",
"Set",
")",
"{",
"if",
"cfgBuilder",
".",
"Bucket",
"==",
"\"",
"\"",
"{",
"c",
".",
"Errorf",
"(",
"requiredFieldError",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"cfgBuilder",
".",
"Bucket",
",",
"\"",
"\"",
")",
"{",
"// TODO(tandrii): change to warning once our validation library supports it.",
"c",
".",
"Errorf",
"(",
"`field \"bucket\" should not include legacy \"luci.<project_name>.\" prefix, given %q`",
",",
"cfgBuilder",
".",
"Bucket",
")",
"\n",
"}",
"\n",
"if",
"cfgBuilder",
".",
"Name",
"==",
"\"",
"\"",
"{",
"c",
".",
"Errorf",
"(",
"requiredFieldError",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"cfgBuilder",
".",
"Repository",
"!=",
"\"",
"\"",
"{",
"if",
"err",
":=",
"gitiles",
".",
"ValidateRepoURL",
"(",
"cfgBuilder",
".",
"Repository",
")",
";",
"err",
"!=",
"nil",
"{",
"c",
".",
"Errorf",
"(",
"badRepoURLError",
",",
"cfgBuilder",
".",
"Repository",
")",
"\n",
"}",
"\n",
"}",
"\n",
"fullName",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cfgBuilder",
".",
"Bucket",
",",
"cfgBuilder",
".",
"Name",
")",
"\n",
"if",
"!",
"builderNames",
".",
"Add",
"(",
"fullName",
")",
"{",
"c",
".",
"Errorf",
"(",
"duplicateBuilderError",
",",
"fullName",
")",
"\n",
"}",
"\n",
"}"
] | // validateBuilder is a helper function for validateConfig which validates
// an individual Builder. | [
"validateBuilder",
"is",
"a",
"helper",
"function",
"for",
"validateConfig",
"which",
"validates",
"an",
"individual",
"Builder",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/luci_notify/config/validate.go#L84-L104 |
8,730 | luci/luci-go | luci_notify/config/validate.go | validateNotifier | func validateNotifier(c *validation.Context, cfgNotifier *notifypb.Notifier, builderNames stringset.Set) {
for i, cfgNotification := range cfgNotifier.Notifications {
c.Enter("notification #%d", i+1)
validateNotification(c, cfgNotification)
c.Exit()
}
for i, cfgBuilder := range cfgNotifier.Builders {
c.Enter("builder #%d", i+1)
validateBuilder(c, cfgBuilder, builderNames)
c.Exit()
}
} | go | func validateNotifier(c *validation.Context, cfgNotifier *notifypb.Notifier, builderNames stringset.Set) {
for i, cfgNotification := range cfgNotifier.Notifications {
c.Enter("notification #%d", i+1)
validateNotification(c, cfgNotification)
c.Exit()
}
for i, cfgBuilder := range cfgNotifier.Builders {
c.Enter("builder #%d", i+1)
validateBuilder(c, cfgBuilder, builderNames)
c.Exit()
}
} | [
"func",
"validateNotifier",
"(",
"c",
"*",
"validation",
".",
"Context",
",",
"cfgNotifier",
"*",
"notifypb",
".",
"Notifier",
",",
"builderNames",
"stringset",
".",
"Set",
")",
"{",
"for",
"i",
",",
"cfgNotification",
":=",
"range",
"cfgNotifier",
".",
"Notifications",
"{",
"c",
".",
"Enter",
"(",
"\"",
"\"",
",",
"i",
"+",
"1",
")",
"\n",
"validateNotification",
"(",
"c",
",",
"cfgNotification",
")",
"\n",
"c",
".",
"Exit",
"(",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"cfgBuilder",
":=",
"range",
"cfgNotifier",
".",
"Builders",
"{",
"c",
".",
"Enter",
"(",
"\"",
"\"",
",",
"i",
"+",
"1",
")",
"\n",
"validateBuilder",
"(",
"c",
",",
"cfgBuilder",
",",
"builderNames",
")",
"\n",
"c",
".",
"Exit",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // validateNotifier validates a Notifier. | [
"validateNotifier",
"validates",
"a",
"Notifier",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/luci_notify/config/validate.go#L107-L118 |
8,731 | luci/luci-go | luci_notify/config/validate.go | validateProjectConfig | func validateProjectConfig(ctx *validation.Context, projectCfg *notifypb.ProjectConfig) {
builderNames := stringset.New(len(projectCfg.Notifiers)) // At least one builder per notifier
for i, cfgNotifier := range projectCfg.Notifiers {
ctx.Enter("notifier #%d", i+1)
validateNotifier(ctx, cfgNotifier, builderNames)
ctx.Exit()
}
} | go | func validateProjectConfig(ctx *validation.Context, projectCfg *notifypb.ProjectConfig) {
builderNames := stringset.New(len(projectCfg.Notifiers)) // At least one builder per notifier
for i, cfgNotifier := range projectCfg.Notifiers {
ctx.Enter("notifier #%d", i+1)
validateNotifier(ctx, cfgNotifier, builderNames)
ctx.Exit()
}
} | [
"func",
"validateProjectConfig",
"(",
"ctx",
"*",
"validation",
".",
"Context",
",",
"projectCfg",
"*",
"notifypb",
".",
"ProjectConfig",
")",
"{",
"builderNames",
":=",
"stringset",
".",
"New",
"(",
"len",
"(",
"projectCfg",
".",
"Notifiers",
")",
")",
"// At least one builder per notifier",
"\n",
"for",
"i",
",",
"cfgNotifier",
":=",
"range",
"projectCfg",
".",
"Notifiers",
"{",
"ctx",
".",
"Enter",
"(",
"\"",
"\"",
",",
"i",
"+",
"1",
")",
"\n",
"validateNotifier",
"(",
"ctx",
",",
"cfgNotifier",
",",
"builderNames",
")",
"\n",
"ctx",
".",
"Exit",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // validateProjectConfig returns an error if the configuration violates any of the
// requirements in the proto definition. | [
"validateProjectConfig",
"returns",
"an",
"error",
"if",
"the",
"configuration",
"violates",
"any",
"of",
"the",
"requirements",
"in",
"the",
"proto",
"definition",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/luci_notify/config/validate.go#L122-L129 |
8,732 | luci/luci-go | luci_notify/config/validate.go | validateSettings | func validateSettings(ctx *validation.Context, settings *notifypb.Settings) {
switch {
case settings.MiloHost == "":
ctx.Errorf(requiredFieldError, "milo_host")
case validation.ValidateHostname(settings.MiloHost) != nil:
ctx.Errorf(invalidFieldError, "milo_host")
}
} | go | func validateSettings(ctx *validation.Context, settings *notifypb.Settings) {
switch {
case settings.MiloHost == "":
ctx.Errorf(requiredFieldError, "milo_host")
case validation.ValidateHostname(settings.MiloHost) != nil:
ctx.Errorf(invalidFieldError, "milo_host")
}
} | [
"func",
"validateSettings",
"(",
"ctx",
"*",
"validation",
".",
"Context",
",",
"settings",
"*",
"notifypb",
".",
"Settings",
")",
"{",
"switch",
"{",
"case",
"settings",
".",
"MiloHost",
"==",
"\"",
"\"",
":",
"ctx",
".",
"Errorf",
"(",
"requiredFieldError",
",",
"\"",
"\"",
")",
"\n",
"case",
"validation",
".",
"ValidateHostname",
"(",
"settings",
".",
"MiloHost",
")",
"!=",
"nil",
":",
"ctx",
".",
"Errorf",
"(",
"invalidFieldError",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // validateSettings returns an error if the service configuration violates any
// of the requirements in the proto definition. | [
"validateSettings",
"returns",
"an",
"error",
"if",
"the",
"service",
"configuration",
"violates",
"any",
"of",
"the",
"requirements",
"in",
"the",
"proto",
"definition",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/luci_notify/config/validate.go#L133-L140 |
8,733 | luci/luci-go | luci_notify/config/validate.go | validateEmailTemplateFile | func validateEmailTemplateFile(ctx *validation.Context, configSet, path string, content []byte) error {
// Validate file name.
rgx := emailTemplateFilenameRegexp(ctx.Context)
if !rgx.MatchString(path) {
ctx.Errorf("filename does not match %q", rgx.String())
}
// Validate file contents.
subject, body, err := splitEmailTemplateFile(string(content))
if err != nil {
ctx.Error(err)
} else {
// Note: Parse does not return an error if the template attempts to
// call an undefined template, e.g. {{template "does-not-exist"}}
if _, err = text.New("subject").Funcs(EmailTemplateFuncs).Parse(subject); err != nil {
ctx.Error(err) // error includes template name
}
// Due to luci-config limitation, we cannot detect an invalid reference to
// a sub-template defined in a different file.
if _, err = html.New("body").Funcs(EmailTemplateFuncs).Parse(body); err != nil {
ctx.Error(err) // error includes template name
}
}
return nil
} | go | func validateEmailTemplateFile(ctx *validation.Context, configSet, path string, content []byte) error {
// Validate file name.
rgx := emailTemplateFilenameRegexp(ctx.Context)
if !rgx.MatchString(path) {
ctx.Errorf("filename does not match %q", rgx.String())
}
// Validate file contents.
subject, body, err := splitEmailTemplateFile(string(content))
if err != nil {
ctx.Error(err)
} else {
// Note: Parse does not return an error if the template attempts to
// call an undefined template, e.g. {{template "does-not-exist"}}
if _, err = text.New("subject").Funcs(EmailTemplateFuncs).Parse(subject); err != nil {
ctx.Error(err) // error includes template name
}
// Due to luci-config limitation, we cannot detect an invalid reference to
// a sub-template defined in a different file.
if _, err = html.New("body").Funcs(EmailTemplateFuncs).Parse(body); err != nil {
ctx.Error(err) // error includes template name
}
}
return nil
} | [
"func",
"validateEmailTemplateFile",
"(",
"ctx",
"*",
"validation",
".",
"Context",
",",
"configSet",
",",
"path",
"string",
",",
"content",
"[",
"]",
"byte",
")",
"error",
"{",
"// Validate file name.",
"rgx",
":=",
"emailTemplateFilenameRegexp",
"(",
"ctx",
".",
"Context",
")",
"\n",
"if",
"!",
"rgx",
".",
"MatchString",
"(",
"path",
")",
"{",
"ctx",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rgx",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Validate file contents.",
"subject",
",",
"body",
",",
"err",
":=",
"splitEmailTemplateFile",
"(",
"string",
"(",
"content",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ctx",
".",
"Error",
"(",
"err",
")",
"\n",
"}",
"else",
"{",
"// Note: Parse does not return an error if the template attempts to",
"// call an undefined template, e.g. {{template \"does-not-exist\"}}",
"if",
"_",
",",
"err",
"=",
"text",
".",
"New",
"(",
"\"",
"\"",
")",
".",
"Funcs",
"(",
"EmailTemplateFuncs",
")",
".",
"Parse",
"(",
"subject",
")",
";",
"err",
"!=",
"nil",
"{",
"ctx",
".",
"Error",
"(",
"err",
")",
"// error includes template name",
"\n",
"}",
"\n",
"// Due to luci-config limitation, we cannot detect an invalid reference to",
"// a sub-template defined in a different file.",
"if",
"_",
",",
"err",
"=",
"html",
".",
"New",
"(",
"\"",
"\"",
")",
".",
"Funcs",
"(",
"EmailTemplateFuncs",
")",
".",
"Parse",
"(",
"body",
")",
";",
"err",
"!=",
"nil",
"{",
"ctx",
".",
"Error",
"(",
"err",
")",
"// error includes template name",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // validateEmailTemplateFile validates an email template file, including
// its filename and contents. | [
"validateEmailTemplateFile",
"validates",
"an",
"email",
"template",
"file",
"including",
"its",
"filename",
"and",
"contents",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/luci_notify/config/validate.go#L144-L168 |
8,734 | luci/luci-go | logdog/server/bundleServicesClient/client.go | RegisterStream | func (c *Client) RegisterStream(ctx context.Context, in *s.RegisterStreamRequest, opts ...grpc.CallOption) (
*s.RegisterStreamResponse, error) {
resp, err := c.bundleRPC(ctx, opts, &s.BatchRequest_Entry{
Value: &s.BatchRequest_Entry_RegisterStream{RegisterStream: in},
})
if err != nil {
return nil, err
}
return resp.GetRegisterStream(), nil
} | go | func (c *Client) RegisterStream(ctx context.Context, in *s.RegisterStreamRequest, opts ...grpc.CallOption) (
*s.RegisterStreamResponse, error) {
resp, err := c.bundleRPC(ctx, opts, &s.BatchRequest_Entry{
Value: &s.BatchRequest_Entry_RegisterStream{RegisterStream: in},
})
if err != nil {
return nil, err
}
return resp.GetRegisterStream(), nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"RegisterStream",
"(",
"ctx",
"context",
".",
"Context",
",",
"in",
"*",
"s",
".",
"RegisterStreamRequest",
",",
"opts",
"...",
"grpc",
".",
"CallOption",
")",
"(",
"*",
"s",
".",
"RegisterStreamResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"c",
".",
"bundleRPC",
"(",
"ctx",
",",
"opts",
",",
"&",
"s",
".",
"BatchRequest_Entry",
"{",
"Value",
":",
"&",
"s",
".",
"BatchRequest_Entry_RegisterStream",
"{",
"RegisterStream",
":",
"in",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"resp",
".",
"GetRegisterStream",
"(",
")",
",",
"nil",
"\n",
"}"
] | // RegisterStream implements ServicesClient. | [
"RegisterStream",
"implements",
"ServicesClient",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/server/bundleServicesClient/client.go#L72-L83 |
8,735 | luci/luci-go | logdog/server/bundleServicesClient/client.go | LoadStream | func (c *Client) LoadStream(ctx context.Context, in *s.LoadStreamRequest, opts ...grpc.CallOption) (
*s.LoadStreamResponse, error) {
resp, err := c.bundleRPC(ctx, opts, &s.BatchRequest_Entry{
Value: &s.BatchRequest_Entry_LoadStream{LoadStream: in},
})
if err != nil {
return nil, err
}
return resp.GetLoadStream(), nil
} | go | func (c *Client) LoadStream(ctx context.Context, in *s.LoadStreamRequest, opts ...grpc.CallOption) (
*s.LoadStreamResponse, error) {
resp, err := c.bundleRPC(ctx, opts, &s.BatchRequest_Entry{
Value: &s.BatchRequest_Entry_LoadStream{LoadStream: in},
})
if err != nil {
return nil, err
}
return resp.GetLoadStream(), nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"LoadStream",
"(",
"ctx",
"context",
".",
"Context",
",",
"in",
"*",
"s",
".",
"LoadStreamRequest",
",",
"opts",
"...",
"grpc",
".",
"CallOption",
")",
"(",
"*",
"s",
".",
"LoadStreamResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"c",
".",
"bundleRPC",
"(",
"ctx",
",",
"opts",
",",
"&",
"s",
".",
"BatchRequest_Entry",
"{",
"Value",
":",
"&",
"s",
".",
"BatchRequest_Entry_LoadStream",
"{",
"LoadStream",
":",
"in",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"resp",
".",
"GetLoadStream",
"(",
")",
",",
"nil",
"\n",
"}"
] | // LoadStream implements ServicesClient. | [
"LoadStream",
"implements",
"ServicesClient",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/server/bundleServicesClient/client.go#L86-L97 |
8,736 | luci/luci-go | logdog/server/bundleServicesClient/client.go | TerminateStream | func (c *Client) TerminateStream(ctx context.Context, in *s.TerminateStreamRequest, opts ...grpc.CallOption) (
*empty.Empty, error) {
_, err := c.bundleRPC(ctx, opts, &s.BatchRequest_Entry{
Value: &s.BatchRequest_Entry_TerminateStream{TerminateStream: in},
})
if err != nil {
return nil, err
}
return &empty.Empty{}, nil
} | go | func (c *Client) TerminateStream(ctx context.Context, in *s.TerminateStreamRequest, opts ...grpc.CallOption) (
*empty.Empty, error) {
_, err := c.bundleRPC(ctx, opts, &s.BatchRequest_Entry{
Value: &s.BatchRequest_Entry_TerminateStream{TerminateStream: in},
})
if err != nil {
return nil, err
}
return &empty.Empty{}, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"TerminateStream",
"(",
"ctx",
"context",
".",
"Context",
",",
"in",
"*",
"s",
".",
"TerminateStreamRequest",
",",
"opts",
"...",
"grpc",
".",
"CallOption",
")",
"(",
"*",
"empty",
".",
"Empty",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"c",
".",
"bundleRPC",
"(",
"ctx",
",",
"opts",
",",
"&",
"s",
".",
"BatchRequest_Entry",
"{",
"Value",
":",
"&",
"s",
".",
"BatchRequest_Entry_TerminateStream",
"{",
"TerminateStream",
":",
"in",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"empty",
".",
"Empty",
"{",
"}",
",",
"nil",
"\n",
"}"
] | // TerminateStream implements ServicesClient. | [
"TerminateStream",
"implements",
"ServicesClient",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/server/bundleServicesClient/client.go#L100-L111 |
8,737 | luci/luci-go | logdog/server/bundleServicesClient/client.go | ArchiveStream | func (c *Client) ArchiveStream(ctx context.Context, in *s.ArchiveStreamRequest, opts ...grpc.CallOption) (
*empty.Empty, error) {
_, err := c.bundleRPC(ctx, opts, &s.BatchRequest_Entry{
Value: &s.BatchRequest_Entry_ArchiveStream{ArchiveStream: in},
})
if err != nil {
return nil, err
}
return &empty.Empty{}, nil
} | go | func (c *Client) ArchiveStream(ctx context.Context, in *s.ArchiveStreamRequest, opts ...grpc.CallOption) (
*empty.Empty, error) {
_, err := c.bundleRPC(ctx, opts, &s.BatchRequest_Entry{
Value: &s.BatchRequest_Entry_ArchiveStream{ArchiveStream: in},
})
if err != nil {
return nil, err
}
return &empty.Empty{}, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ArchiveStream",
"(",
"ctx",
"context",
".",
"Context",
",",
"in",
"*",
"s",
".",
"ArchiveStreamRequest",
",",
"opts",
"...",
"grpc",
".",
"CallOption",
")",
"(",
"*",
"empty",
".",
"Empty",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"c",
".",
"bundleRPC",
"(",
"ctx",
",",
"opts",
",",
"&",
"s",
".",
"BatchRequest_Entry",
"{",
"Value",
":",
"&",
"s",
".",
"BatchRequest_Entry_ArchiveStream",
"{",
"ArchiveStream",
":",
"in",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"empty",
".",
"Empty",
"{",
"}",
",",
"nil",
"\n",
"}"
] | // ArchiveStream implements ServicesClient. | [
"ArchiveStream",
"implements",
"ServicesClient",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/server/bundleServicesClient/client.go#L114-L125 |
8,738 | luci/luci-go | logdog/server/bundleServicesClient/client.go | Flush | func (c *Client) Flush() {
c.initBundler()
c.bundler.Flush()
c.outstanding.Wait()
} | go | func (c *Client) Flush() {
c.initBundler()
c.bundler.Flush()
c.outstanding.Wait()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Flush",
"(",
")",
"{",
"c",
".",
"initBundler",
"(",
")",
"\n",
"c",
".",
"bundler",
".",
"Flush",
"(",
")",
"\n",
"c",
".",
"outstanding",
".",
"Wait",
"(",
")",
"\n",
"}"
] | // Flush flushes the Bundler. It should be called when terminating to ensure
// that buffered client requests have been completed. | [
"Flush",
"flushes",
"the",
"Bundler",
".",
"It",
"should",
"be",
"called",
"when",
"terminating",
"to",
"ensure",
"that",
"buffered",
"client",
"requests",
"have",
"been",
"completed",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/server/bundleServicesClient/client.go#L129-L133 |
8,739 | luci/luci-go | logdog/server/bundleServicesClient/client.go | bundleRPC | func (c *Client) bundleRPC(ctx context.Context, opts []grpc.CallOption, req *s.BatchRequest_Entry) (*s.BatchResponse_Entry, error) {
c.initBundler()
be := &batchEntry{
req: req,
ctx: ctx,
opts: opts,
complete: make(chan *s.BatchResponse_Entry, 1),
}
if err := c.addEntry(be); err != nil {
return nil, err
}
resp := <-be.complete
if e := resp.GetErr(); e != nil {
return nil, e.ToError()
}
return resp, nil
} | go | func (c *Client) bundleRPC(ctx context.Context, opts []grpc.CallOption, req *s.BatchRequest_Entry) (*s.BatchResponse_Entry, error) {
c.initBundler()
be := &batchEntry{
req: req,
ctx: ctx,
opts: opts,
complete: make(chan *s.BatchResponse_Entry, 1),
}
if err := c.addEntry(be); err != nil {
return nil, err
}
resp := <-be.complete
if e := resp.GetErr(); e != nil {
return nil, e.ToError()
}
return resp, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"bundleRPC",
"(",
"ctx",
"context",
".",
"Context",
",",
"opts",
"[",
"]",
"grpc",
".",
"CallOption",
",",
"req",
"*",
"s",
".",
"BatchRequest_Entry",
")",
"(",
"*",
"s",
".",
"BatchResponse_Entry",
",",
"error",
")",
"{",
"c",
".",
"initBundler",
"(",
")",
"\n\n",
"be",
":=",
"&",
"batchEntry",
"{",
"req",
":",
"req",
",",
"ctx",
":",
"ctx",
",",
"opts",
":",
"opts",
",",
"complete",
":",
"make",
"(",
"chan",
"*",
"s",
".",
"BatchResponse_Entry",
",",
"1",
")",
",",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"addEntry",
"(",
"be",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
":=",
"<-",
"be",
".",
"complete",
"\n",
"if",
"e",
":=",
"resp",
".",
"GetErr",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"return",
"nil",
",",
"e",
".",
"ToError",
"(",
")",
"\n",
"}",
"\n",
"return",
"resp",
",",
"nil",
"\n",
"}"
] | // bundleRPC adds req to the underlying Bundler, blocks until it completes, and
// returns its response. | [
"bundleRPC",
"adds",
"req",
"to",
"the",
"underlying",
"Bundler",
"blocks",
"until",
"it",
"completes",
"and",
"returns",
"its",
"response",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/server/bundleServicesClient/client.go#L147-L165 |
8,740 | luci/luci-go | common/iotools/bufferingreaderat.go | init | func (l *blocksLRU) init(capacity int) {
l.capacity = capacity
l.blocks = make(map[int64]*list.Element, capacity)
l.ll.Init()
} | go | func (l *blocksLRU) init(capacity int) {
l.capacity = capacity
l.blocks = make(map[int64]*list.Element, capacity)
l.ll.Init()
} | [
"func",
"(",
"l",
"*",
"blocksLRU",
")",
"init",
"(",
"capacity",
"int",
")",
"{",
"l",
".",
"capacity",
"=",
"capacity",
"\n",
"l",
".",
"blocks",
"=",
"make",
"(",
"map",
"[",
"int64",
"]",
"*",
"list",
".",
"Element",
",",
"capacity",
")",
"\n",
"l",
".",
"ll",
".",
"Init",
"(",
")",
"\n",
"}"
] | // init initializes LRU guts. | [
"init",
"initializes",
"LRU",
"guts",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/iotools/bufferingreaderat.go#L41-L45 |
8,741 | luci/luci-go | common/iotools/bufferingreaderat.go | prepareForAdd | func (l *blocksLRU) prepareForAdd() {
switch {
case l.ll.Len() > l.capacity:
panic("impossible")
case l.ll.Len() == l.capacity:
oldest := l.ll.Remove(l.ll.Back()).(block)
delete(l.blocks, oldest.offset)
l.evicted(oldest)
}
} | go | func (l *blocksLRU) prepareForAdd() {
switch {
case l.ll.Len() > l.capacity:
panic("impossible")
case l.ll.Len() == l.capacity:
oldest := l.ll.Remove(l.ll.Back()).(block)
delete(l.blocks, oldest.offset)
l.evicted(oldest)
}
} | [
"func",
"(",
"l",
"*",
"blocksLRU",
")",
"prepareForAdd",
"(",
")",
"{",
"switch",
"{",
"case",
"l",
".",
"ll",
".",
"Len",
"(",
")",
">",
"l",
".",
"capacity",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"case",
"l",
".",
"ll",
".",
"Len",
"(",
")",
"==",
"l",
".",
"capacity",
":",
"oldest",
":=",
"l",
".",
"ll",
".",
"Remove",
"(",
"l",
".",
"ll",
".",
"Back",
"(",
")",
")",
".",
"(",
"block",
")",
"\n",
"delete",
"(",
"l",
".",
"blocks",
",",
"oldest",
".",
"offset",
")",
"\n",
"l",
".",
"evicted",
"(",
"oldest",
")",
"\n",
"}",
"\n",
"}"
] | // prepareForAdd removes oldest item from the list if it is at the capacity.
//
// Does nothing if it's not yet full. | [
"prepareForAdd",
"removes",
"oldest",
"item",
"from",
"the",
"list",
"if",
"it",
"is",
"at",
"the",
"capacity",
".",
"Does",
"nothing",
"if",
"it",
"s",
"not",
"yet",
"full",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/iotools/bufferingreaderat.go#L60-L69 |
8,742 | luci/luci-go | common/iotools/bufferingreaderat.go | grabBuf | func (r *bufferingReaderAt) grabBuf() []byte {
if len(r.pool) != 0 {
b := r.pool[len(r.pool)-1]
r.pool = r.pool[:len(r.pool)-1]
return b
}
return make([]byte, r.blockSize)
} | go | func (r *bufferingReaderAt) grabBuf() []byte {
if len(r.pool) != 0 {
b := r.pool[len(r.pool)-1]
r.pool = r.pool[:len(r.pool)-1]
return b
}
return make([]byte, r.blockSize)
} | [
"func",
"(",
"r",
"*",
"bufferingReaderAt",
")",
"grabBuf",
"(",
")",
"[",
"]",
"byte",
"{",
"if",
"len",
"(",
"r",
".",
"pool",
")",
"!=",
"0",
"{",
"b",
":=",
"r",
".",
"pool",
"[",
"len",
"(",
"r",
".",
"pool",
")",
"-",
"1",
"]",
"\n",
"r",
".",
"pool",
"=",
"r",
".",
"pool",
"[",
":",
"len",
"(",
"r",
".",
"pool",
")",
"-",
"1",
"]",
"\n",
"return",
"b",
"\n",
"}",
"\n",
"return",
"make",
"(",
"[",
"]",
"byte",
",",
"r",
".",
"blockSize",
")",
"\n",
"}"
] | // grabBuf returns a byte slice of blockSize size. | [
"grabBuf",
"returns",
"a",
"byte",
"slice",
"of",
"blockSize",
"size",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/iotools/bufferingreaderat.go#L129-L136 |
8,743 | luci/luci-go | common/iotools/bufferingreaderat.go | recycleBuf | func (r *bufferingReaderAt) recycleBuf(b []byte) {
if cap(b) != r.blockSize {
panic("trying to return a buffer not initially requested via grabBuf")
}
if len(r.pool)+1 > cap(r.pool) {
panic("unexpected growth of byte buffer pool beyond capacity")
}
r.pool = append(r.pool, b[:cap(b)])
} | go | func (r *bufferingReaderAt) recycleBuf(b []byte) {
if cap(b) != r.blockSize {
panic("trying to return a buffer not initially requested via grabBuf")
}
if len(r.pool)+1 > cap(r.pool) {
panic("unexpected growth of byte buffer pool beyond capacity")
}
r.pool = append(r.pool, b[:cap(b)])
} | [
"func",
"(",
"r",
"*",
"bufferingReaderAt",
")",
"recycleBuf",
"(",
"b",
"[",
"]",
"byte",
")",
"{",
"if",
"cap",
"(",
"b",
")",
"!=",
"r",
".",
"blockSize",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"r",
".",
"pool",
")",
"+",
"1",
">",
"cap",
"(",
"r",
".",
"pool",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"r",
".",
"pool",
"=",
"append",
"(",
"r",
".",
"pool",
",",
"b",
"[",
":",
"cap",
"(",
"b",
")",
"]",
")",
"\n",
"}"
] | // recycleBuf is called when the buffer is no longer needed to put it for reuse. | [
"recycleBuf",
"is",
"called",
"when",
"the",
"buffer",
"is",
"no",
"longer",
"needed",
"to",
"put",
"it",
"for",
"reuse",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/iotools/bufferingreaderat.go#L139-L147 |
8,744 | luci/luci-go | common/iotools/bufferingreaderat.go | ReadAt | func (r *bufferingReaderAt) ReadAt(p []byte, offset int64) (read int, err error) {
if len(p) == 0 {
return r.r.ReadAt(p, offset)
}
r.l.Lock()
defer r.l.Unlock()
bs := int64(r.blockSize)
blockOff := int64((offset / bs) * bs) // block-aligned offset
// Sequentially read blocks that intersect with the requested segment.
for {
// err here may be EOF or some other error. We consume all data first and
// deal with errors later.
data, err := r.readBlock(blockOff)
// The first block may be read from the middle, since 'min' may be less than
// 'offset'.
if offset > blockOff {
pos := offset - blockOff // position inside the block to read from
if pos < int64(len(data)) {
data = data[pos:] // grab the tail of the block
} else {
data = nil // we probably hit EOF before the requested offset
}
}
// 'copy' copies min of len(data) and whatever space is left in 'p', so this
// is always safe. The last block may be copied partially (if there's no
// space left in 'p').
read += copy(p[read:], data)
switch {
case read == len(p):
// We managed to read everything we wanted, ignore the last error, if any.
return read, nil
case err != nil:
return read, err
}
// The last read was successful. Per ReaderAt contract (that we double
// checked in readBlock) it means it read ALL requested data (and we request
// 'bs' bytes). So move on to the next block.
blockOff += bs
}
} | go | func (r *bufferingReaderAt) ReadAt(p []byte, offset int64) (read int, err error) {
if len(p) == 0 {
return r.r.ReadAt(p, offset)
}
r.l.Lock()
defer r.l.Unlock()
bs := int64(r.blockSize)
blockOff := int64((offset / bs) * bs) // block-aligned offset
// Sequentially read blocks that intersect with the requested segment.
for {
// err here may be EOF or some other error. We consume all data first and
// deal with errors later.
data, err := r.readBlock(blockOff)
// The first block may be read from the middle, since 'min' may be less than
// 'offset'.
if offset > blockOff {
pos := offset - blockOff // position inside the block to read from
if pos < int64(len(data)) {
data = data[pos:] // grab the tail of the block
} else {
data = nil // we probably hit EOF before the requested offset
}
}
// 'copy' copies min of len(data) and whatever space is left in 'p', so this
// is always safe. The last block may be copied partially (if there's no
// space left in 'p').
read += copy(p[read:], data)
switch {
case read == len(p):
// We managed to read everything we wanted, ignore the last error, if any.
return read, nil
case err != nil:
return read, err
}
// The last read was successful. Per ReaderAt contract (that we double
// checked in readBlock) it means it read ALL requested data (and we request
// 'bs' bytes). So move on to the next block.
blockOff += bs
}
} | [
"func",
"(",
"r",
"*",
"bufferingReaderAt",
")",
"ReadAt",
"(",
"p",
"[",
"]",
"byte",
",",
"offset",
"int64",
")",
"(",
"read",
"int",
",",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"p",
")",
"==",
"0",
"{",
"return",
"r",
".",
"r",
".",
"ReadAt",
"(",
"p",
",",
"offset",
")",
"\n",
"}",
"\n\n",
"r",
".",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"l",
".",
"Unlock",
"(",
")",
"\n\n",
"bs",
":=",
"int64",
"(",
"r",
".",
"blockSize",
")",
"\n",
"blockOff",
":=",
"int64",
"(",
"(",
"offset",
"/",
"bs",
")",
"*",
"bs",
")",
"// block-aligned offset",
"\n\n",
"// Sequentially read blocks that intersect with the requested segment.",
"for",
"{",
"// err here may be EOF or some other error. We consume all data first and",
"// deal with errors later.",
"data",
",",
"err",
":=",
"r",
".",
"readBlock",
"(",
"blockOff",
")",
"\n\n",
"// The first block may be read from the middle, since 'min' may be less than",
"// 'offset'.",
"if",
"offset",
">",
"blockOff",
"{",
"pos",
":=",
"offset",
"-",
"blockOff",
"// position inside the block to read from",
"\n",
"if",
"pos",
"<",
"int64",
"(",
"len",
"(",
"data",
")",
")",
"{",
"data",
"=",
"data",
"[",
"pos",
":",
"]",
"// grab the tail of the block",
"\n",
"}",
"else",
"{",
"data",
"=",
"nil",
"// we probably hit EOF before the requested offset",
"\n",
"}",
"\n",
"}",
"\n\n",
"// 'copy' copies min of len(data) and whatever space is left in 'p', so this",
"// is always safe. The last block may be copied partially (if there's no",
"// space left in 'p').",
"read",
"+=",
"copy",
"(",
"p",
"[",
"read",
":",
"]",
",",
"data",
")",
"\n\n",
"switch",
"{",
"case",
"read",
"==",
"len",
"(",
"p",
")",
":",
"// We managed to read everything we wanted, ignore the last error, if any.",
"return",
"read",
",",
"nil",
"\n",
"case",
"err",
"!=",
"nil",
":",
"return",
"read",
",",
"err",
"\n",
"}",
"\n\n",
"// The last read was successful. Per ReaderAt contract (that we double",
"// checked in readBlock) it means it read ALL requested data (and we request",
"// 'bs' bytes). So move on to the next block.",
"blockOff",
"+=",
"bs",
"\n",
"}",
"\n",
"}"
] | // ReadAt implements io.ReaderAt interface. | [
"ReadAt",
"implements",
"io",
".",
"ReaderAt",
"interface",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/iotools/bufferingreaderat.go#L200-L246 |
8,745 | luci/luci-go | milo/frontend/ui/builder.go | SwarmingURL | func (mp *MachinePool) SwarmingURL() string {
if mp.SwarmingHost == "" {
return ""
}
u := &url.URL{
Scheme: "https",
Host: mp.SwarmingHost,
Path: "botlist",
RawQuery: url.Values{
"f": mp.Dimensions,
}.Encode(),
}
return u.String()
} | go | func (mp *MachinePool) SwarmingURL() string {
if mp.SwarmingHost == "" {
return ""
}
u := &url.URL{
Scheme: "https",
Host: mp.SwarmingHost,
Path: "botlist",
RawQuery: url.Values{
"f": mp.Dimensions,
}.Encode(),
}
return u.String()
} | [
"func",
"(",
"mp",
"*",
"MachinePool",
")",
"SwarmingURL",
"(",
")",
"string",
"{",
"if",
"mp",
".",
"SwarmingHost",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"u",
":=",
"&",
"url",
".",
"URL",
"{",
"Scheme",
":",
"\"",
"\"",
",",
"Host",
":",
"mp",
".",
"SwarmingHost",
",",
"Path",
":",
"\"",
"\"",
",",
"RawQuery",
":",
"url",
".",
"Values",
"{",
"\"",
"\"",
":",
"mp",
".",
"Dimensions",
",",
"}",
".",
"Encode",
"(",
")",
",",
"}",
"\n",
"return",
"u",
".",
"String",
"(",
")",
"\n",
"}"
] | // SwarmingURL returns the swarming bot URL for the machine pool, if available. | [
"SwarmingURL",
"returns",
"the",
"swarming",
"bot",
"URL",
"for",
"the",
"machine",
"pool",
"if",
"available",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/frontend/ui/builder.go#L110-L123 |
8,746 | luci/luci-go | milo/frontend/ui/builder.go | NewMachinePool | func NewMachinePool(c context.Context, botPool *model.BotPool) *MachinePool {
fiveMinAgo := clock.Now(c).Add(-time.Minute * 5)
result := &MachinePool{
Total: len(botPool.Bots),
Bots: make([]Bot, len(botPool.Bots)),
Dimensions: botPool.Descriptor.Dimensions().Format(),
SwarmingHost: botPool.Descriptor.Host(),
}
for i, bot := range botPool.Bots {
uiBot := Bot{bot, bot.Status} // Wrap the model.Bot
if bot.Status == model.Offline && bot.LastSeen.After(fiveMinAgo) {
// If the bot has been offline for less than 5 minutes, mark it as busy.
uiBot.Status = model.Busy
}
switch bot.Status {
case model.Idle:
result.Idle++
case model.Busy:
result.Busy++
case model.Offline:
result.Offline++
}
result.Bots[i] = uiBot
}
return result
} | go | func NewMachinePool(c context.Context, botPool *model.BotPool) *MachinePool {
fiveMinAgo := clock.Now(c).Add(-time.Minute * 5)
result := &MachinePool{
Total: len(botPool.Bots),
Bots: make([]Bot, len(botPool.Bots)),
Dimensions: botPool.Descriptor.Dimensions().Format(),
SwarmingHost: botPool.Descriptor.Host(),
}
for i, bot := range botPool.Bots {
uiBot := Bot{bot, bot.Status} // Wrap the model.Bot
if bot.Status == model.Offline && bot.LastSeen.After(fiveMinAgo) {
// If the bot has been offline for less than 5 minutes, mark it as busy.
uiBot.Status = model.Busy
}
switch bot.Status {
case model.Idle:
result.Idle++
case model.Busy:
result.Busy++
case model.Offline:
result.Offline++
}
result.Bots[i] = uiBot
}
return result
} | [
"func",
"NewMachinePool",
"(",
"c",
"context",
".",
"Context",
",",
"botPool",
"*",
"model",
".",
"BotPool",
")",
"*",
"MachinePool",
"{",
"fiveMinAgo",
":=",
"clock",
".",
"Now",
"(",
"c",
")",
".",
"Add",
"(",
"-",
"time",
".",
"Minute",
"*",
"5",
")",
"\n",
"result",
":=",
"&",
"MachinePool",
"{",
"Total",
":",
"len",
"(",
"botPool",
".",
"Bots",
")",
",",
"Bots",
":",
"make",
"(",
"[",
"]",
"Bot",
",",
"len",
"(",
"botPool",
".",
"Bots",
")",
")",
",",
"Dimensions",
":",
"botPool",
".",
"Descriptor",
".",
"Dimensions",
"(",
")",
".",
"Format",
"(",
")",
",",
"SwarmingHost",
":",
"botPool",
".",
"Descriptor",
".",
"Host",
"(",
")",
",",
"}",
"\n",
"for",
"i",
",",
"bot",
":=",
"range",
"botPool",
".",
"Bots",
"{",
"uiBot",
":=",
"Bot",
"{",
"bot",
",",
"bot",
".",
"Status",
"}",
"// Wrap the model.Bot",
"\n",
"if",
"bot",
".",
"Status",
"==",
"model",
".",
"Offline",
"&&",
"bot",
".",
"LastSeen",
".",
"After",
"(",
"fiveMinAgo",
")",
"{",
"// If the bot has been offline for less than 5 minutes, mark it as busy.",
"uiBot",
".",
"Status",
"=",
"model",
".",
"Busy",
"\n",
"}",
"\n",
"switch",
"bot",
".",
"Status",
"{",
"case",
"model",
".",
"Idle",
":",
"result",
".",
"Idle",
"++",
"\n",
"case",
"model",
".",
"Busy",
":",
"result",
".",
"Busy",
"++",
"\n",
"case",
"model",
".",
"Offline",
":",
"result",
".",
"Offline",
"++",
"\n",
"}",
"\n",
"result",
".",
"Bots",
"[",
"i",
"]",
"=",
"uiBot",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}"
] | // NewMachinePool calculates stats from a model.Bot and generates a MachinePool.
// This requires a context because setting the UI Status field requires the current time. | [
"NewMachinePool",
"calculates",
"stats",
"from",
"a",
"model",
".",
"Bot",
"and",
"generates",
"a",
"MachinePool",
".",
"This",
"requires",
"a",
"context",
"because",
"setting",
"the",
"UI",
"Status",
"field",
"requires",
"the",
"current",
"time",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/frontend/ui/builder.go#L127-L152 |
8,747 | luci/luci-go | dm/api/service/v1/walk_graph_normalize.go | Normalize | func (e *WalkGraphReq_Exclude) Normalize() error {
if len(e.Quests) > 0 {
e.Quests = e.Quests[:set.Uniq(sort.StringSlice(e.Quests))]
}
return e.Attempts.Normalize()
} | go | func (e *WalkGraphReq_Exclude) Normalize() error {
if len(e.Quests) > 0 {
e.Quests = e.Quests[:set.Uniq(sort.StringSlice(e.Quests))]
}
return e.Attempts.Normalize()
} | [
"func",
"(",
"e",
"*",
"WalkGraphReq_Exclude",
")",
"Normalize",
"(",
")",
"error",
"{",
"if",
"len",
"(",
"e",
".",
"Quests",
")",
">",
"0",
"{",
"e",
".",
"Quests",
"=",
"e",
".",
"Quests",
"[",
":",
"set",
".",
"Uniq",
"(",
"sort",
".",
"StringSlice",
"(",
"e",
".",
"Quests",
")",
")",
"]",
"\n",
"}",
"\n",
"return",
"e",
".",
"Attempts",
".",
"Normalize",
"(",
")",
"\n",
"}"
] | // Normalize returns an error iff the WalkGraphReq_Exclude is invalid. | [
"Normalize",
"returns",
"an",
"error",
"iff",
"the",
"WalkGraphReq_Exclude",
"is",
"invalid",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/dm/api/service/v1/walk_graph_normalize.go#L68-L73 |
8,748 | luci/luci-go | dm/api/service/v1/walk_graph_normalize.go | Normalize | func (w *WalkGraphReq) Normalize() error {
if w.Auth != nil {
if err := w.Auth.Normalize(); err != nil {
return err
}
}
if w.Query == nil {
return errors.New("must specify a Query")
}
if err := w.Query.Normalize(); err != nil {
return err
}
if w.Mode == nil {
w.Mode = &WalkGraphReq_Mode{}
}
if w.Limit != nil {
if w.Limit.MaxDepth < -1 {
return errors.New("limit.max_depth must be >= -1")
}
if google.DurationFromProto(w.Limit.GetMaxTime()) < 0 {
return errors.New("limit.max_time must be positive")
}
} else {
w.Limit = &WalkGraphReq_Limit{}
}
if w.Limit.MaxDataSize == 0 {
w.Limit.MaxDataSize = DefaultLimitMaxDataSize
}
if w.Limit.MaxDataSize > MaxLimitMaxDataSize {
w.Limit.MaxDataSize = MaxLimitMaxDataSize
}
if w.Include == nil {
w.Include = &WalkGraphReq_Include{
Quest: &WalkGraphReq_Include_Options{},
Attempt: &WalkGraphReq_Include_Options{},
Execution: &WalkGraphReq_Include_Options{},
}
} else {
if w.Include.Quest == nil {
w.Include.Quest = &WalkGraphReq_Include_Options{}
} else if w.Include.Quest.Result || w.Include.Quest.Abnormal || w.Include.Quest.Expired {
return errors.New("include.quest does not support result, abnormal or expired")
}
if w.Include.Attempt == nil {
w.Include.Attempt = &WalkGraphReq_Include_Options{}
} else {
if w.Include.Attempt.Result {
w.Include.Attempt.Data = true
}
}
if w.Include.Execution == nil {
w.Include.Execution = &WalkGraphReq_Include_Options{}
}
}
if w.Exclude == nil {
w.Exclude = &WalkGraphReq_Exclude{}
}
return w.Exclude.Normalize()
} | go | func (w *WalkGraphReq) Normalize() error {
if w.Auth != nil {
if err := w.Auth.Normalize(); err != nil {
return err
}
}
if w.Query == nil {
return errors.New("must specify a Query")
}
if err := w.Query.Normalize(); err != nil {
return err
}
if w.Mode == nil {
w.Mode = &WalkGraphReq_Mode{}
}
if w.Limit != nil {
if w.Limit.MaxDepth < -1 {
return errors.New("limit.max_depth must be >= -1")
}
if google.DurationFromProto(w.Limit.GetMaxTime()) < 0 {
return errors.New("limit.max_time must be positive")
}
} else {
w.Limit = &WalkGraphReq_Limit{}
}
if w.Limit.MaxDataSize == 0 {
w.Limit.MaxDataSize = DefaultLimitMaxDataSize
}
if w.Limit.MaxDataSize > MaxLimitMaxDataSize {
w.Limit.MaxDataSize = MaxLimitMaxDataSize
}
if w.Include == nil {
w.Include = &WalkGraphReq_Include{
Quest: &WalkGraphReq_Include_Options{},
Attempt: &WalkGraphReq_Include_Options{},
Execution: &WalkGraphReq_Include_Options{},
}
} else {
if w.Include.Quest == nil {
w.Include.Quest = &WalkGraphReq_Include_Options{}
} else if w.Include.Quest.Result || w.Include.Quest.Abnormal || w.Include.Quest.Expired {
return errors.New("include.quest does not support result, abnormal or expired")
}
if w.Include.Attempt == nil {
w.Include.Attempt = &WalkGraphReq_Include_Options{}
} else {
if w.Include.Attempt.Result {
w.Include.Attempt.Data = true
}
}
if w.Include.Execution == nil {
w.Include.Execution = &WalkGraphReq_Include_Options{}
}
}
if w.Exclude == nil {
w.Exclude = &WalkGraphReq_Exclude{}
}
return w.Exclude.Normalize()
} | [
"func",
"(",
"w",
"*",
"WalkGraphReq",
")",
"Normalize",
"(",
")",
"error",
"{",
"if",
"w",
".",
"Auth",
"!=",
"nil",
"{",
"if",
"err",
":=",
"w",
".",
"Auth",
".",
"Normalize",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"w",
".",
"Query",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"w",
".",
"Query",
".",
"Normalize",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"w",
".",
"Mode",
"==",
"nil",
"{",
"w",
".",
"Mode",
"=",
"&",
"WalkGraphReq_Mode",
"{",
"}",
"\n",
"}",
"\n\n",
"if",
"w",
".",
"Limit",
"!=",
"nil",
"{",
"if",
"w",
".",
"Limit",
".",
"MaxDepth",
"<",
"-",
"1",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"google",
".",
"DurationFromProto",
"(",
"w",
".",
"Limit",
".",
"GetMaxTime",
"(",
")",
")",
"<",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"w",
".",
"Limit",
"=",
"&",
"WalkGraphReq_Limit",
"{",
"}",
"\n",
"}",
"\n",
"if",
"w",
".",
"Limit",
".",
"MaxDataSize",
"==",
"0",
"{",
"w",
".",
"Limit",
".",
"MaxDataSize",
"=",
"DefaultLimitMaxDataSize",
"\n",
"}",
"\n",
"if",
"w",
".",
"Limit",
".",
"MaxDataSize",
">",
"MaxLimitMaxDataSize",
"{",
"w",
".",
"Limit",
".",
"MaxDataSize",
"=",
"MaxLimitMaxDataSize",
"\n",
"}",
"\n\n",
"if",
"w",
".",
"Include",
"==",
"nil",
"{",
"w",
".",
"Include",
"=",
"&",
"WalkGraphReq_Include",
"{",
"Quest",
":",
"&",
"WalkGraphReq_Include_Options",
"{",
"}",
",",
"Attempt",
":",
"&",
"WalkGraphReq_Include_Options",
"{",
"}",
",",
"Execution",
":",
"&",
"WalkGraphReq_Include_Options",
"{",
"}",
",",
"}",
"\n",
"}",
"else",
"{",
"if",
"w",
".",
"Include",
".",
"Quest",
"==",
"nil",
"{",
"w",
".",
"Include",
".",
"Quest",
"=",
"&",
"WalkGraphReq_Include_Options",
"{",
"}",
"\n",
"}",
"else",
"if",
"w",
".",
"Include",
".",
"Quest",
".",
"Result",
"||",
"w",
".",
"Include",
".",
"Quest",
".",
"Abnormal",
"||",
"w",
".",
"Include",
".",
"Quest",
".",
"Expired",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"w",
".",
"Include",
".",
"Attempt",
"==",
"nil",
"{",
"w",
".",
"Include",
".",
"Attempt",
"=",
"&",
"WalkGraphReq_Include_Options",
"{",
"}",
"\n",
"}",
"else",
"{",
"if",
"w",
".",
"Include",
".",
"Attempt",
".",
"Result",
"{",
"w",
".",
"Include",
".",
"Attempt",
".",
"Data",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"w",
".",
"Include",
".",
"Execution",
"==",
"nil",
"{",
"w",
".",
"Include",
".",
"Execution",
"=",
"&",
"WalkGraphReq_Include_Options",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"w",
".",
"Exclude",
"==",
"nil",
"{",
"w",
".",
"Exclude",
"=",
"&",
"WalkGraphReq_Exclude",
"{",
"}",
"\n",
"}",
"\n",
"return",
"w",
".",
"Exclude",
".",
"Normalize",
"(",
")",
"\n",
"}"
] | // Normalize returns an error iff the WalkGraphReq is invalid. | [
"Normalize",
"returns",
"an",
"error",
"iff",
"the",
"WalkGraphReq",
"is",
"invalid",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/dm/api/service/v1/walk_graph_normalize.go#L76-L141 |
8,749 | luci/luci-go | cipd/client/cipd/builder/builder.go | zipInputFiles | func zipInputFiles(ctx context.Context, files []fs.File, w io.Writer, level int) error {
logging.Infof(ctx, "About to zip %d files with compression level %d", len(files), level)
writer := zip.NewWriter(w)
defer writer.Close()
writer.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {
return flate.NewWriter(out, level)
})
// Reports zipping progress to the log each second.
lastReport := time.Time{}
progress := func(count int) {
if time.Since(lastReport) > time.Second {
lastReport = time.Now()
logging.Infof(ctx, "Zipping files: %d files left", len(files)-count)
}
}
for i, in := range files {
progress(i)
// Bail out early if context is canceled.
if err := ctx.Err(); err != nil {
return err
}
// Intentionally do not add file mode to make zip archive
// deterministic. Timestamps sometimes need to be preserved, but normally
// are zero valued. See also zip.FileInfoHeader() implementation.
fh := zip.FileHeader{
Name: in.Name(),
Method: zip.Deflate,
}
if level == 0 || in.Symlink() || isLikelyAlreadyCompressed(in) {
fh.Method = zip.Store
}
mode := os.FileMode(0400)
if in.Executable() {
mode |= 0100
}
if in.Writable() {
mode |= 0200
}
if in.Symlink() {
mode |= os.ModeSymlink
}
fh.SetMode(mode)
if !in.ModTime().IsZero() {
fh.SetModTime(in.ModTime())
}
fh.ExternalAttrs |= uint32(in.WinAttrs())
dst, err := writer.CreateHeader(&fh)
if err != nil {
return err
}
if in.Symlink() {
err = zipSymlinkFile(dst, in)
} else {
err = zipRegularFile(dst, in)
}
if err != nil {
return err
}
}
return nil
} | go | func zipInputFiles(ctx context.Context, files []fs.File, w io.Writer, level int) error {
logging.Infof(ctx, "About to zip %d files with compression level %d", len(files), level)
writer := zip.NewWriter(w)
defer writer.Close()
writer.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {
return flate.NewWriter(out, level)
})
// Reports zipping progress to the log each second.
lastReport := time.Time{}
progress := func(count int) {
if time.Since(lastReport) > time.Second {
lastReport = time.Now()
logging.Infof(ctx, "Zipping files: %d files left", len(files)-count)
}
}
for i, in := range files {
progress(i)
// Bail out early if context is canceled.
if err := ctx.Err(); err != nil {
return err
}
// Intentionally do not add file mode to make zip archive
// deterministic. Timestamps sometimes need to be preserved, but normally
// are zero valued. See also zip.FileInfoHeader() implementation.
fh := zip.FileHeader{
Name: in.Name(),
Method: zip.Deflate,
}
if level == 0 || in.Symlink() || isLikelyAlreadyCompressed(in) {
fh.Method = zip.Store
}
mode := os.FileMode(0400)
if in.Executable() {
mode |= 0100
}
if in.Writable() {
mode |= 0200
}
if in.Symlink() {
mode |= os.ModeSymlink
}
fh.SetMode(mode)
if !in.ModTime().IsZero() {
fh.SetModTime(in.ModTime())
}
fh.ExternalAttrs |= uint32(in.WinAttrs())
dst, err := writer.CreateHeader(&fh)
if err != nil {
return err
}
if in.Symlink() {
err = zipSymlinkFile(dst, in)
} else {
err = zipRegularFile(dst, in)
}
if err != nil {
return err
}
}
return nil
} | [
"func",
"zipInputFiles",
"(",
"ctx",
"context",
".",
"Context",
",",
"files",
"[",
"]",
"fs",
".",
"File",
",",
"w",
"io",
".",
"Writer",
",",
"level",
"int",
")",
"error",
"{",
"logging",
".",
"Infof",
"(",
"ctx",
",",
"\"",
"\"",
",",
"len",
"(",
"files",
")",
",",
"level",
")",
"\n\n",
"writer",
":=",
"zip",
".",
"NewWriter",
"(",
"w",
")",
"\n",
"defer",
"writer",
".",
"Close",
"(",
")",
"\n\n",
"writer",
".",
"RegisterCompressor",
"(",
"zip",
".",
"Deflate",
",",
"func",
"(",
"out",
"io",
".",
"Writer",
")",
"(",
"io",
".",
"WriteCloser",
",",
"error",
")",
"{",
"return",
"flate",
".",
"NewWriter",
"(",
"out",
",",
"level",
")",
"\n",
"}",
")",
"\n\n",
"// Reports zipping progress to the log each second.",
"lastReport",
":=",
"time",
".",
"Time",
"{",
"}",
"\n",
"progress",
":=",
"func",
"(",
"count",
"int",
")",
"{",
"if",
"time",
".",
"Since",
"(",
"lastReport",
")",
">",
"time",
".",
"Second",
"{",
"lastReport",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"logging",
".",
"Infof",
"(",
"ctx",
",",
"\"",
"\"",
",",
"len",
"(",
"files",
")",
"-",
"count",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"in",
":=",
"range",
"files",
"{",
"progress",
"(",
"i",
")",
"\n\n",
"// Bail out early if context is canceled.",
"if",
"err",
":=",
"ctx",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Intentionally do not add file mode to make zip archive",
"// deterministic. Timestamps sometimes need to be preserved, but normally",
"// are zero valued. See also zip.FileInfoHeader() implementation.",
"fh",
":=",
"zip",
".",
"FileHeader",
"{",
"Name",
":",
"in",
".",
"Name",
"(",
")",
",",
"Method",
":",
"zip",
".",
"Deflate",
",",
"}",
"\n",
"if",
"level",
"==",
"0",
"||",
"in",
".",
"Symlink",
"(",
")",
"||",
"isLikelyAlreadyCompressed",
"(",
"in",
")",
"{",
"fh",
".",
"Method",
"=",
"zip",
".",
"Store",
"\n",
"}",
"\n\n",
"mode",
":=",
"os",
".",
"FileMode",
"(",
"0400",
")",
"\n",
"if",
"in",
".",
"Executable",
"(",
")",
"{",
"mode",
"|=",
"0100",
"\n",
"}",
"\n",
"if",
"in",
".",
"Writable",
"(",
")",
"{",
"mode",
"|=",
"0200",
"\n",
"}",
"\n",
"if",
"in",
".",
"Symlink",
"(",
")",
"{",
"mode",
"|=",
"os",
".",
"ModeSymlink",
"\n",
"}",
"\n",
"fh",
".",
"SetMode",
"(",
"mode",
")",
"\n\n",
"if",
"!",
"in",
".",
"ModTime",
"(",
")",
".",
"IsZero",
"(",
")",
"{",
"fh",
".",
"SetModTime",
"(",
"in",
".",
"ModTime",
"(",
")",
")",
"\n",
"}",
"\n\n",
"fh",
".",
"ExternalAttrs",
"|=",
"uint32",
"(",
"in",
".",
"WinAttrs",
"(",
")",
")",
"\n\n",
"dst",
",",
"err",
":=",
"writer",
".",
"CreateHeader",
"(",
"&",
"fh",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"in",
".",
"Symlink",
"(",
")",
"{",
"err",
"=",
"zipSymlinkFile",
"(",
"dst",
",",
"in",
")",
"\n",
"}",
"else",
"{",
"err",
"=",
"zipRegularFile",
"(",
"dst",
",",
"in",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // zipInputFiles deterministically builds a zip archive out of input files and
// writes it to the writer. Files are written in the order given. | [
"zipInputFiles",
"deterministically",
"builds",
"a",
"zip",
"archive",
"out",
"of",
"input",
"files",
"and",
"writes",
"it",
"to",
"the",
"writer",
".",
"Files",
"are",
"written",
"in",
"the",
"order",
"given",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/cipd/client/cipd/builder/builder.go#L139-L210 |
8,750 | luci/luci-go | cipd/client/cipd/builder/builder.go | makeManifestFile | func makeManifestFile(opts Options) (fs.File, error) {
if opts.VersionFile != "" && !fs.IsCleanSlashPath(opts.VersionFile) {
return nil, fmt.Errorf("version file path should be a clean path relative to a package root: %s", opts.VersionFile)
}
if err := pkg.ValidateInstallMode(opts.InstallMode); err != nil {
return nil, err
}
formatVer := pkg.ManifestFormatVersion
if opts.OverrideFormatVersion != "" {
formatVer = opts.OverrideFormatVersion
}
buf := &bytes.Buffer{}
err := pkg.WriteManifest(&pkg.Manifest{
FormatVersion: formatVer,
PackageName: opts.PackageName,
VersionFile: opts.VersionFile,
InstallMode: opts.InstallMode,
}, buf)
if err != nil {
return nil, err
}
out := manifestFile(buf.Bytes())
return &out, nil
} | go | func makeManifestFile(opts Options) (fs.File, error) {
if opts.VersionFile != "" && !fs.IsCleanSlashPath(opts.VersionFile) {
return nil, fmt.Errorf("version file path should be a clean path relative to a package root: %s", opts.VersionFile)
}
if err := pkg.ValidateInstallMode(opts.InstallMode); err != nil {
return nil, err
}
formatVer := pkg.ManifestFormatVersion
if opts.OverrideFormatVersion != "" {
formatVer = opts.OverrideFormatVersion
}
buf := &bytes.Buffer{}
err := pkg.WriteManifest(&pkg.Manifest{
FormatVersion: formatVer,
PackageName: opts.PackageName,
VersionFile: opts.VersionFile,
InstallMode: opts.InstallMode,
}, buf)
if err != nil {
return nil, err
}
out := manifestFile(buf.Bytes())
return &out, nil
} | [
"func",
"makeManifestFile",
"(",
"opts",
"Options",
")",
"(",
"fs",
".",
"File",
",",
"error",
")",
"{",
"if",
"opts",
".",
"VersionFile",
"!=",
"\"",
"\"",
"&&",
"!",
"fs",
".",
"IsCleanSlashPath",
"(",
"opts",
".",
"VersionFile",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"opts",
".",
"VersionFile",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"pkg",
".",
"ValidateInstallMode",
"(",
"opts",
".",
"InstallMode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"formatVer",
":=",
"pkg",
".",
"ManifestFormatVersion",
"\n",
"if",
"opts",
".",
"OverrideFormatVersion",
"!=",
"\"",
"\"",
"{",
"formatVer",
"=",
"opts",
".",
"OverrideFormatVersion",
"\n",
"}",
"\n",
"buf",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"err",
":=",
"pkg",
".",
"WriteManifest",
"(",
"&",
"pkg",
".",
"Manifest",
"{",
"FormatVersion",
":",
"formatVer",
",",
"PackageName",
":",
"opts",
".",
"PackageName",
",",
"VersionFile",
":",
"opts",
".",
"VersionFile",
",",
"InstallMode",
":",
"opts",
".",
"InstallMode",
",",
"}",
",",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"out",
":=",
"manifestFile",
"(",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"return",
"&",
"out",
",",
"nil",
"\n",
"}"
] | // makeManifestFile generates a package manifest file and returns it as
// File interface. | [
"makeManifestFile",
"generates",
"a",
"package",
"manifest",
"file",
"and",
"returns",
"it",
"as",
"File",
"interface",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/cipd/client/cipd/builder/builder.go#L343-L366 |
8,751 | luci/luci-go | common/tsmon/state.go | NewState | func NewState() *State {
return &State{
store: store.NewNilStore(),
monitor: monitor.NewNilMonitor(),
invokeGlobalCallbacksOnFlush: true,
}
} | go | func NewState() *State {
return &State{
store: store.NewNilStore(),
monitor: monitor.NewNilMonitor(),
invokeGlobalCallbacksOnFlush: true,
}
} | [
"func",
"NewState",
"(",
")",
"*",
"State",
"{",
"return",
"&",
"State",
"{",
"store",
":",
"store",
".",
"NewNilStore",
"(",
")",
",",
"monitor",
":",
"monitor",
".",
"NewNilMonitor",
"(",
")",
",",
"invokeGlobalCallbacksOnFlush",
":",
"true",
",",
"}",
"\n",
"}"
] | // NewState returns a new State instance, configured with a nil store and nil
// monitor. By default, global callbacks that are registered will be invoked
// when flushing registered metrics. | [
"NewState",
"returns",
"a",
"new",
"State",
"instance",
"configured",
"with",
"a",
"nil",
"store",
"and",
"nil",
"monitor",
".",
"By",
"default",
"global",
"callbacks",
"that",
"are",
"registered",
"will",
"be",
"invoked",
"when",
"flushing",
"registered",
"metrics",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L44-L50 |
8,752 | luci/luci-go | common/tsmon/state.go | Callbacks | func (s *State) Callbacks() []Callback {
s.mu.RLock()
defer s.mu.RUnlock()
return append([]Callback{}, s.callbacks...)
} | go | func (s *State) Callbacks() []Callback {
s.mu.RLock()
defer s.mu.RUnlock()
return append([]Callback{}, s.callbacks...)
} | [
"func",
"(",
"s",
"*",
"State",
")",
"Callbacks",
"(",
")",
"[",
"]",
"Callback",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"append",
"(",
"[",
"]",
"Callback",
"{",
"}",
",",
"s",
".",
"callbacks",
"...",
")",
"\n",
"}"
] | // Callbacks returns all registered Callbacks. | [
"Callbacks",
"returns",
"all",
"registered",
"Callbacks",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L61-L66 |
8,753 | luci/luci-go | common/tsmon/state.go | GlobalCallbacks | func (s *State) GlobalCallbacks() []GlobalCallback {
s.mu.RLock()
defer s.mu.RUnlock()
return append([]GlobalCallback{}, s.globalCallbacks...)
} | go | func (s *State) GlobalCallbacks() []GlobalCallback {
s.mu.RLock()
defer s.mu.RUnlock()
return append([]GlobalCallback{}, s.globalCallbacks...)
} | [
"func",
"(",
"s",
"*",
"State",
")",
"GlobalCallbacks",
"(",
")",
"[",
"]",
"GlobalCallback",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"append",
"(",
"[",
"]",
"GlobalCallback",
"{",
"}",
",",
"s",
".",
"globalCallbacks",
"...",
")",
"\n",
"}"
] | // GlobalCallbacks returns all registered GlobalCallbacks. | [
"GlobalCallbacks",
"returns",
"all",
"registered",
"GlobalCallbacks",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L69-L74 |
8,754 | luci/luci-go | common/tsmon/state.go | InhibitGlobalCallbacksOnFlush | func (s *State) InhibitGlobalCallbacksOnFlush() {
s.mu.Lock()
defer s.mu.Unlock()
s.invokeGlobalCallbacksOnFlush = false
} | go | func (s *State) InhibitGlobalCallbacksOnFlush() {
s.mu.Lock()
defer s.mu.Unlock()
s.invokeGlobalCallbacksOnFlush = false
} | [
"func",
"(",
"s",
"*",
"State",
")",
"InhibitGlobalCallbacksOnFlush",
"(",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
".",
"invokeGlobalCallbacksOnFlush",
"=",
"false",
"\n",
"}"
] | // InhibitGlobalCallbacksOnFlush signals that the registered global callbacks
// are not to be executed upon flushing registered metrics. | [
"InhibitGlobalCallbacksOnFlush",
"signals",
"that",
"the",
"registered",
"global",
"callbacks",
"are",
"not",
"to",
"be",
"executed",
"upon",
"flushing",
"registered",
"metrics",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L78-L83 |
8,755 | luci/luci-go | common/tsmon/state.go | InvokeGlobalCallbacksOnFlush | func (s *State) InvokeGlobalCallbacksOnFlush() {
s.mu.Lock()
defer s.mu.Unlock()
s.invokeGlobalCallbacksOnFlush = true
} | go | func (s *State) InvokeGlobalCallbacksOnFlush() {
s.mu.Lock()
defer s.mu.Unlock()
s.invokeGlobalCallbacksOnFlush = true
} | [
"func",
"(",
"s",
"*",
"State",
")",
"InvokeGlobalCallbacksOnFlush",
"(",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
".",
"invokeGlobalCallbacksOnFlush",
"=",
"true",
"\n",
"}"
] | // InvokeGlobalCallbacksOnFlush signals that the registered global callbacks
// are to be be executed upon flushing registered metrics. | [
"InvokeGlobalCallbacksOnFlush",
"signals",
"that",
"the",
"registered",
"global",
"callbacks",
"are",
"to",
"be",
"be",
"executed",
"upon",
"flushing",
"registered",
"metrics",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L87-L92 |
8,756 | luci/luci-go | common/tsmon/state.go | Monitor | func (s *State) Monitor() monitor.Monitor {
s.mu.RLock()
defer s.mu.RUnlock()
return s.monitor
} | go | func (s *State) Monitor() monitor.Monitor {
s.mu.RLock()
defer s.mu.RUnlock()
return s.monitor
} | [
"func",
"(",
"s",
"*",
"State",
")",
"Monitor",
"(",
")",
"monitor",
".",
"Monitor",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"s",
".",
"monitor",
"\n",
"}"
] | // Monitor returns the State's monitor. | [
"Monitor",
"returns",
"the",
"State",
"s",
"monitor",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L95-L100 |
8,757 | luci/luci-go | common/tsmon/state.go | Store | func (s *State) Store() store.Store {
s.mu.RLock()
defer s.mu.RUnlock()
return s.store
} | go | func (s *State) Store() store.Store {
s.mu.RLock()
defer s.mu.RUnlock()
return s.store
} | [
"func",
"(",
"s",
"*",
"State",
")",
"Store",
"(",
")",
"store",
".",
"Store",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"s",
".",
"store",
"\n",
"}"
] | // Store returns the State's store. | [
"Store",
"returns",
"the",
"State",
"s",
"store",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L119-L124 |
8,758 | luci/luci-go | common/tsmon/state.go | SetMonitor | func (s *State) SetMonitor(m monitor.Monitor) {
s.mu.Lock()
defer s.mu.Unlock()
s.monitor = m
} | go | func (s *State) SetMonitor(m monitor.Monitor) {
s.mu.Lock()
defer s.mu.Unlock()
s.monitor = m
} | [
"func",
"(",
"s",
"*",
"State",
")",
"SetMonitor",
"(",
"m",
"monitor",
".",
"Monitor",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
".",
"monitor",
"=",
"m",
"\n",
"}"
] | // SetMonitor sets the Store's monitor. | [
"SetMonitor",
"sets",
"the",
"Store",
"s",
"monitor",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L127-L132 |
8,759 | luci/luci-go | common/tsmon/state.go | SetStore | func (s *State) SetStore(st store.Store) {
s.mu.Lock()
defer s.mu.Unlock()
s.store = st
} | go | func (s *State) SetStore(st store.Store) {
s.mu.Lock()
defer s.mu.Unlock()
s.store = st
} | [
"func",
"(",
"s",
"*",
"State",
")",
"SetStore",
"(",
"st",
"store",
".",
"Store",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
".",
"store",
"=",
"st",
"\n",
"}"
] | // SetStore changes the metric store. All metrics that were registered with
// the old store will be re-registered on the new store. | [
"SetStore",
"changes",
"the",
"metric",
"store",
".",
"All",
"metrics",
"that",
"were",
"registered",
"with",
"the",
"old",
"store",
"will",
"be",
"re",
"-",
"registered",
"on",
"the",
"new",
"store",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L136-L141 |
8,760 | luci/luci-go | common/tsmon/state.go | ResetCumulativeMetrics | func (s *State) ResetCumulativeMetrics(ctx context.Context) {
store := s.Store()
registry.Iter(func(m types.Metric) {
if m.Info().ValueType.IsCumulative() {
store.Reset(ctx, m)
}
})
} | go | func (s *State) ResetCumulativeMetrics(ctx context.Context) {
store := s.Store()
registry.Iter(func(m types.Metric) {
if m.Info().ValueType.IsCumulative() {
store.Reset(ctx, m)
}
})
} | [
"func",
"(",
"s",
"*",
"State",
")",
"ResetCumulativeMetrics",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"store",
":=",
"s",
".",
"Store",
"(",
")",
"\n\n",
"registry",
".",
"Iter",
"(",
"func",
"(",
"m",
"types",
".",
"Metric",
")",
"{",
"if",
"m",
".",
"Info",
"(",
")",
".",
"ValueType",
".",
"IsCumulative",
"(",
")",
"{",
"store",
".",
"Reset",
"(",
"ctx",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}"
] | // ResetCumulativeMetrics resets only cumulative metrics. | [
"ResetCumulativeMetrics",
"resets",
"only",
"cumulative",
"metrics",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L144-L152 |
8,761 | luci/luci-go | common/tsmon/state.go | RunGlobalCallbacks | func (s *State) RunGlobalCallbacks(ctx context.Context) {
for _, cb := range s.GlobalCallbacks() {
cb.Callback(ctx)
}
} | go | func (s *State) RunGlobalCallbacks(ctx context.Context) {
for _, cb := range s.GlobalCallbacks() {
cb.Callback(ctx)
}
} | [
"func",
"(",
"s",
"*",
"State",
")",
"RunGlobalCallbacks",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"for",
"_",
",",
"cb",
":=",
"range",
"s",
".",
"GlobalCallbacks",
"(",
")",
"{",
"cb",
".",
"Callback",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"}"
] | // RunGlobalCallbacks runs all registered global callbacks that produce global
// metrics.
//
// See RegisterGlobalCallback for more info. | [
"RunGlobalCallbacks",
"runs",
"all",
"registered",
"global",
"callbacks",
"that",
"produce",
"global",
"metrics",
".",
"See",
"RegisterGlobalCallback",
"for",
"more",
"info",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L158-L162 |
8,762 | luci/luci-go | common/tsmon/state.go | Flush | func (s *State) Flush(ctx context.Context, mon monitor.Monitor) error {
if mon == nil {
mon = s.Monitor()
}
if mon == nil {
return errors.New("no tsmon Monitor is configured")
}
// Run any callbacks that have been registered to populate values in callback
// metrics.
s.runCallbacks(ctx)
if s.invokeGlobalCallbacksOnFlush {
s.RunGlobalCallbacks(ctx)
}
cells := s.store.GetAll(ctx)
if len(cells) == 0 {
return nil
}
logging.Debugf(ctx, "Starting tsmon flush: %d cells", len(cells))
defer logging.Debugf(ctx, "Finished tsmon flush")
// Split up the payload into chunks if there are too many cells.
chunkSize := mon.ChunkSize()
if chunkSize == 0 {
chunkSize = len(cells)
}
var failedSends int
var lastErr error
for len(cells) > 0 {
count := minInt(chunkSize, len(cells))
if err := mon.Send(ctx, cells[:count]); err != nil {
logging.Errorf(ctx, "Failed to send %d cells: %v", count, err)
failedSends += count
lastErr = err
// Continue anyway.
}
cells = cells[count:]
}
logging.Debugf(ctx, "Sent %d/%d cells", len(cells)-failedSends, len(cells))
s.resetGlobalCallbackMetrics(ctx)
return lastErr
} | go | func (s *State) Flush(ctx context.Context, mon monitor.Monitor) error {
if mon == nil {
mon = s.Monitor()
}
if mon == nil {
return errors.New("no tsmon Monitor is configured")
}
// Run any callbacks that have been registered to populate values in callback
// metrics.
s.runCallbacks(ctx)
if s.invokeGlobalCallbacksOnFlush {
s.RunGlobalCallbacks(ctx)
}
cells := s.store.GetAll(ctx)
if len(cells) == 0 {
return nil
}
logging.Debugf(ctx, "Starting tsmon flush: %d cells", len(cells))
defer logging.Debugf(ctx, "Finished tsmon flush")
// Split up the payload into chunks if there are too many cells.
chunkSize := mon.ChunkSize()
if chunkSize == 0 {
chunkSize = len(cells)
}
var failedSends int
var lastErr error
for len(cells) > 0 {
count := minInt(chunkSize, len(cells))
if err := mon.Send(ctx, cells[:count]); err != nil {
logging.Errorf(ctx, "Failed to send %d cells: %v", count, err)
failedSends += count
lastErr = err
// Continue anyway.
}
cells = cells[count:]
}
logging.Debugf(ctx, "Sent %d/%d cells", len(cells)-failedSends, len(cells))
s.resetGlobalCallbackMetrics(ctx)
return lastErr
} | [
"func",
"(",
"s",
"*",
"State",
")",
"Flush",
"(",
"ctx",
"context",
".",
"Context",
",",
"mon",
"monitor",
".",
"Monitor",
")",
"error",
"{",
"if",
"mon",
"==",
"nil",
"{",
"mon",
"=",
"s",
".",
"Monitor",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"mon",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Run any callbacks that have been registered to populate values in callback",
"// metrics.",
"s",
".",
"runCallbacks",
"(",
"ctx",
")",
"\n",
"if",
"s",
".",
"invokeGlobalCallbacksOnFlush",
"{",
"s",
".",
"RunGlobalCallbacks",
"(",
"ctx",
")",
"\n",
"}",
"\n\n",
"cells",
":=",
"s",
".",
"store",
".",
"GetAll",
"(",
"ctx",
")",
"\n",
"if",
"len",
"(",
"cells",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"logging",
".",
"Debugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"len",
"(",
"cells",
")",
")",
"\n",
"defer",
"logging",
".",
"Debugf",
"(",
"ctx",
",",
"\"",
"\"",
")",
"\n\n",
"// Split up the payload into chunks if there are too many cells.",
"chunkSize",
":=",
"mon",
".",
"ChunkSize",
"(",
")",
"\n",
"if",
"chunkSize",
"==",
"0",
"{",
"chunkSize",
"=",
"len",
"(",
"cells",
")",
"\n",
"}",
"\n\n",
"var",
"failedSends",
"int",
"\n",
"var",
"lastErr",
"error",
"\n\n",
"for",
"len",
"(",
"cells",
")",
">",
"0",
"{",
"count",
":=",
"minInt",
"(",
"chunkSize",
",",
"len",
"(",
"cells",
")",
")",
"\n",
"if",
"err",
":=",
"mon",
".",
"Send",
"(",
"ctx",
",",
"cells",
"[",
":",
"count",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Errorf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"count",
",",
"err",
")",
"\n",
"failedSends",
"+=",
"count",
"\n",
"lastErr",
"=",
"err",
"\n",
"// Continue anyway.",
"}",
"\n",
"cells",
"=",
"cells",
"[",
"count",
":",
"]",
"\n",
"}",
"\n\n",
"logging",
".",
"Debugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"len",
"(",
"cells",
")",
"-",
"failedSends",
",",
"len",
"(",
"cells",
")",
")",
"\n\n",
"s",
".",
"resetGlobalCallbackMetrics",
"(",
"ctx",
")",
"\n\n",
"return",
"lastErr",
"\n",
"}"
] | // Flush sends all the metrics that are registered in the application.
//
// Uses given monitor if not nil, otherwise the State's current monitor. | [
"Flush",
"sends",
"all",
"the",
"metrics",
"that",
"are",
"registered",
"in",
"the",
"application",
".",
"Uses",
"given",
"monitor",
"if",
"not",
"nil",
"otherwise",
"the",
"State",
"s",
"current",
"monitor",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L167-L216 |
8,763 | luci/luci-go | common/tsmon/state.go | resetGlobalCallbackMetrics | func (s *State) resetGlobalCallbackMetrics(ctx context.Context) {
store := s.Store()
for _, cb := range s.GlobalCallbacks() {
for _, m := range cb.metrics {
store.Reset(ctx, m)
}
}
} | go | func (s *State) resetGlobalCallbackMetrics(ctx context.Context) {
store := s.Store()
for _, cb := range s.GlobalCallbacks() {
for _, m := range cb.metrics {
store.Reset(ctx, m)
}
}
} | [
"func",
"(",
"s",
"*",
"State",
")",
"resetGlobalCallbackMetrics",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"store",
":=",
"s",
".",
"Store",
"(",
")",
"\n\n",
"for",
"_",
",",
"cb",
":=",
"range",
"s",
".",
"GlobalCallbacks",
"(",
")",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"cb",
".",
"metrics",
"{",
"store",
".",
"Reset",
"(",
"ctx",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // resetGlobalCallbackMetrics resets metrics produced by global callbacks.
//
// See RegisterGlobalCallback for more info. | [
"resetGlobalCallbackMetrics",
"resets",
"metrics",
"produced",
"by",
"global",
"callbacks",
".",
"See",
"RegisterGlobalCallback",
"for",
"more",
"info",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L221-L229 |
8,764 | luci/luci-go | common/tsmon/state.go | runCallbacks | func (s *State) runCallbacks(ctx context.Context) {
for _, cb := range s.Callbacks() {
cb(ctx)
}
} | go | func (s *State) runCallbacks(ctx context.Context) {
for _, cb := range s.Callbacks() {
cb(ctx)
}
} | [
"func",
"(",
"s",
"*",
"State",
")",
"runCallbacks",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"for",
"_",
",",
"cb",
":=",
"range",
"s",
".",
"Callbacks",
"(",
")",
"{",
"cb",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"}"
] | // runCallbacks runs any callbacks that have been registered to populate values
// in callback metrics. | [
"runCallbacks",
"runs",
"any",
"callbacks",
"that",
"have",
"been",
"registered",
"to",
"populate",
"values",
"in",
"callback",
"metrics",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/tsmon/state.go#L233-L237 |
8,765 | luci/luci-go | logdog/client/butler/buffered_callback/datagram.go | assertGetDatagram | func assertGetDatagram(le *logpb.LogEntry) *logpb.Datagram {
if dg := le.GetDatagram(); dg == nil {
panic(
errors.Annotate(
InvalidStreamType,
fmt.Sprintf("got %T, expected *logpb.LogEntry_Datagram", le.Content),
).Err(),
)
} else {
return dg
}
} | go | func assertGetDatagram(le *logpb.LogEntry) *logpb.Datagram {
if dg := le.GetDatagram(); dg == nil {
panic(
errors.Annotate(
InvalidStreamType,
fmt.Sprintf("got %T, expected *logpb.LogEntry_Datagram", le.Content),
).Err(),
)
} else {
return dg
}
} | [
"func",
"assertGetDatagram",
"(",
"le",
"*",
"logpb",
".",
"LogEntry",
")",
"*",
"logpb",
".",
"Datagram",
"{",
"if",
"dg",
":=",
"le",
".",
"GetDatagram",
"(",
")",
";",
"dg",
"==",
"nil",
"{",
"panic",
"(",
"errors",
".",
"Annotate",
"(",
"InvalidStreamType",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"le",
".",
"Content",
")",
",",
")",
".",
"Err",
"(",
")",
",",
")",
"\n",
"}",
"else",
"{",
"return",
"dg",
"\n",
"}",
"\n",
"}"
] | // assertGetDatagram panics if the passed LogEntry does not contain Datagram data, or returns it. | [
"assertGetDatagram",
"panics",
"if",
"the",
"passed",
"LogEntry",
"does",
"not",
"contain",
"Datagram",
"data",
"or",
"returns",
"it",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/client/butler/buffered_callback/datagram.go#L26-L37 |
8,766 | luci/luci-go | appengine/datastorecache/manager.go | installCronRoute | func (m *manager) installCronRoute(path string, r *router.Router, base router.MiddlewareChain) {
r.GET(path, base, errHTTPHandler(m.handleManageCronGET))
} | go | func (m *manager) installCronRoute(path string, r *router.Router, base router.MiddlewareChain) {
r.GET(path, base, errHTTPHandler(m.handleManageCronGET))
} | [
"func",
"(",
"m",
"*",
"manager",
")",
"installCronRoute",
"(",
"path",
"string",
",",
"r",
"*",
"router",
".",
"Router",
",",
"base",
"router",
".",
"MiddlewareChain",
")",
"{",
"r",
".",
"GET",
"(",
"path",
",",
"base",
",",
"errHTTPHandler",
"(",
"m",
".",
"handleManageCronGET",
")",
")",
"\n",
"}"
] | // installCronRoute installs a handler for this manager's cron task into the
// supplied Router at the specified path.
//
// It is recommended to assert in the middleware that this endpoint is only
// accessible from a cron task. | [
"installCronRoute",
"installs",
"a",
"handler",
"for",
"this",
"manager",
"s",
"cron",
"task",
"into",
"the",
"supplied",
"Router",
"at",
"the",
"specified",
"path",
".",
"It",
"is",
"recommended",
"to",
"assert",
"in",
"the",
"middleware",
"that",
"this",
"endpoint",
"is",
"only",
"accessible",
"from",
"a",
"cron",
"task",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/appengine/datastorecache/manager.go#L84-L86 |
8,767 | luci/luci-go | logdog/client/butlerlib/streamproto/streamType.go | DefaultContentType | func (t StreamType) DefaultContentType() types.ContentType {
switch logpb.StreamType(t) {
case logpb.StreamType_TEXT:
return types.ContentTypeText
case logpb.StreamType_DATAGRAM:
return types.ContentTypeLogdogDatagram
case logpb.StreamType_BINARY:
fallthrough
default:
return types.ContentTypeBinary
}
} | go | func (t StreamType) DefaultContentType() types.ContentType {
switch logpb.StreamType(t) {
case logpb.StreamType_TEXT:
return types.ContentTypeText
case logpb.StreamType_DATAGRAM:
return types.ContentTypeLogdogDatagram
case logpb.StreamType_BINARY:
fallthrough
default:
return types.ContentTypeBinary
}
} | [
"func",
"(",
"t",
"StreamType",
")",
"DefaultContentType",
"(",
")",
"types",
".",
"ContentType",
"{",
"switch",
"logpb",
".",
"StreamType",
"(",
"t",
")",
"{",
"case",
"logpb",
".",
"StreamType_TEXT",
":",
"return",
"types",
".",
"ContentTypeText",
"\n\n",
"case",
"logpb",
".",
"StreamType_DATAGRAM",
":",
"return",
"types",
".",
"ContentTypeLogdogDatagram",
"\n\n",
"case",
"logpb",
".",
"StreamType_BINARY",
":",
"fallthrough",
"\n",
"default",
":",
"return",
"types",
".",
"ContentTypeBinary",
"\n",
"}",
"\n",
"}"
] | // DefaultContentType returns the default ContentType for a given stream type. | [
"DefaultContentType",
"returns",
"the",
"default",
"ContentType",
"for",
"a",
"given",
"stream",
"type",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/logdog/client/butlerlib/streamproto/streamType.go#L31-L44 |
8,768 | luci/luci-go | common/api/gerrit/gerrit.go | NormalizeGerritURL | func NormalizeGerritURL(gerritURL string) (string, error) {
u, err := url.Parse(gerritURL)
if err != nil {
return "", err
}
if u.Scheme != "https" {
return "", fmt.Errorf("%s should start with https://", gerritURL)
}
if !strings.HasSuffix(u.Host, "-review.googlesource.com") {
return "", errors.New("only *-review.googlesource.com Gerrits supported")
}
if u.Fragment != "" {
return "", errors.New("no fragments allowed in gerritURL")
}
if u.Path != "" && u.Path != "/" {
return "", errors.New("Unexpected path in URL")
}
if u.Path != "/" {
u.Path = "/"
}
return u.String(), nil
} | go | func NormalizeGerritURL(gerritURL string) (string, error) {
u, err := url.Parse(gerritURL)
if err != nil {
return "", err
}
if u.Scheme != "https" {
return "", fmt.Errorf("%s should start with https://", gerritURL)
}
if !strings.HasSuffix(u.Host, "-review.googlesource.com") {
return "", errors.New("only *-review.googlesource.com Gerrits supported")
}
if u.Fragment != "" {
return "", errors.New("no fragments allowed in gerritURL")
}
if u.Path != "" && u.Path != "/" {
return "", errors.New("Unexpected path in URL")
}
if u.Path != "/" {
u.Path = "/"
}
return u.String(), nil
} | [
"func",
"NormalizeGerritURL",
"(",
"gerritURL",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"gerritURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"u",
".",
"Scheme",
"!=",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"gerritURL",
")",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"u",
".",
"Host",
",",
"\"",
"\"",
")",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"Fragment",
"!=",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"Path",
"!=",
"\"",
"\"",
"&&",
"u",
".",
"Path",
"!=",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"Path",
"!=",
"\"",
"\"",
"{",
"u",
".",
"Path",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"u",
".",
"String",
"(",
")",
",",
"nil",
"\n",
"}"
] | // NormalizeGerritURL returns canonical for Gerrit URL.
//
// error is returned if validation fails. | [
"NormalizeGerritURL",
"returns",
"canonical",
"for",
"Gerrit",
"URL",
".",
"error",
"is",
"returned",
"if",
"validation",
"fails",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/api/gerrit/gerrit.go#L246-L267 |
8,769 | luci/luci-go | common/api/gerrit/gerrit.go | NewClient | func NewClient(c *http.Client, gerritURL string) (*Client, error) {
u, err := NormalizeGerritURL(gerritURL)
if err != nil {
return nil, err
}
pu, err := url.Parse(u)
if err != nil {
return nil, err
}
return &Client{c, *pu}, nil
} | go | func NewClient(c *http.Client, gerritURL string) (*Client, error) {
u, err := NormalizeGerritURL(gerritURL)
if err != nil {
return nil, err
}
pu, err := url.Parse(u)
if err != nil {
return nil, err
}
return &Client{c, *pu}, nil
} | [
"func",
"NewClient",
"(",
"c",
"*",
"http",
".",
"Client",
",",
"gerritURL",
"string",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"NormalizeGerritURL",
"(",
"gerritURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"pu",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"u",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Client",
"{",
"c",
",",
"*",
"pu",
"}",
",",
"nil",
"\n",
"}"
] | // NewClient creates a new instance of Client and validates and stores
// the URL to reach Gerrit. The result is wrapped inside a Client so that
// the apis can be called directly on the value returned by this function. | [
"NewClient",
"creates",
"a",
"new",
"instance",
"of",
"Client",
"and",
"validates",
"and",
"stores",
"the",
"URL",
"to",
"reach",
"Gerrit",
".",
"The",
"result",
"is",
"wrapped",
"inside",
"a",
"Client",
"so",
"that",
"the",
"apis",
"can",
"be",
"called",
"directly",
"on",
"the",
"value",
"returned",
"by",
"this",
"function",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/api/gerrit/gerrit.go#L282-L292 |
8,770 | luci/luci-go | common/api/gerrit/gerrit.go | queryString | func (qr *ChangeQueryParams) queryString() url.Values {
qs := make(url.Values, len(qr.Options)+3)
qs.Add("q", qr.Query)
if qr.N > 0 {
qs.Add("n", strconv.Itoa(qr.N))
}
if qr.S > 0 {
qs.Add("S", strconv.Itoa(qr.S))
}
for _, o := range qr.Options {
qs.Add("o", o)
}
return qs
} | go | func (qr *ChangeQueryParams) queryString() url.Values {
qs := make(url.Values, len(qr.Options)+3)
qs.Add("q", qr.Query)
if qr.N > 0 {
qs.Add("n", strconv.Itoa(qr.N))
}
if qr.S > 0 {
qs.Add("S", strconv.Itoa(qr.S))
}
for _, o := range qr.Options {
qs.Add("o", o)
}
return qs
} | [
"func",
"(",
"qr",
"*",
"ChangeQueryParams",
")",
"queryString",
"(",
")",
"url",
".",
"Values",
"{",
"qs",
":=",
"make",
"(",
"url",
".",
"Values",
",",
"len",
"(",
"qr",
".",
"Options",
")",
"+",
"3",
")",
"\n",
"qs",
".",
"Add",
"(",
"\"",
"\"",
",",
"qr",
".",
"Query",
")",
"\n",
"if",
"qr",
".",
"N",
">",
"0",
"{",
"qs",
".",
"Add",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"qr",
".",
"N",
")",
")",
"\n",
"}",
"\n",
"if",
"qr",
".",
"S",
">",
"0",
"{",
"qs",
".",
"Add",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"qr",
".",
"S",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"qr",
".",
"Options",
"{",
"qs",
".",
"Add",
"(",
"\"",
"\"",
",",
"o",
")",
"\n",
"}",
"\n",
"return",
"qs",
"\n",
"}"
] | // queryString renders the ChangeQueryParams as a url.Values. | [
"queryString",
"renders",
"the",
"ChangeQueryParams",
"as",
"a",
"url",
".",
"Values",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/api/gerrit/gerrit.go#L314-L327 |
8,771 | luci/luci-go | common/api/gerrit/gerrit.go | ChangeQuery | func (c *Client) ChangeQuery(ctx context.Context, qr ChangeQueryParams) ([]*Change, bool, error) {
var resp struct {
Collection []*Change
}
if _, err := c.get(ctx, "a/changes/", qr.queryString(), &resp.Collection); err != nil {
return nil, false, err
}
result := resp.Collection
if len(result) == 0 {
return nil, false, nil
}
moreChanges := result[len(result)-1].MoreChanges
result[len(result)-1].MoreChanges = false
return result, moreChanges, nil
} | go | func (c *Client) ChangeQuery(ctx context.Context, qr ChangeQueryParams) ([]*Change, bool, error) {
var resp struct {
Collection []*Change
}
if _, err := c.get(ctx, "a/changes/", qr.queryString(), &resp.Collection); err != nil {
return nil, false, err
}
result := resp.Collection
if len(result) == 0 {
return nil, false, nil
}
moreChanges := result[len(result)-1].MoreChanges
result[len(result)-1].MoreChanges = false
return result, moreChanges, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ChangeQuery",
"(",
"ctx",
"context",
".",
"Context",
",",
"qr",
"ChangeQueryParams",
")",
"(",
"[",
"]",
"*",
"Change",
",",
"bool",
",",
"error",
")",
"{",
"var",
"resp",
"struct",
"{",
"Collection",
"[",
"]",
"*",
"Change",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"c",
".",
"get",
"(",
"ctx",
",",
"\"",
"\"",
",",
"qr",
".",
"queryString",
"(",
")",
",",
"&",
"resp",
".",
"Collection",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"err",
"\n",
"}",
"\n",
"result",
":=",
"resp",
".",
"Collection",
"\n",
"if",
"len",
"(",
"result",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"false",
",",
"nil",
"\n",
"}",
"\n",
"moreChanges",
":=",
"result",
"[",
"len",
"(",
"result",
")",
"-",
"1",
"]",
".",
"MoreChanges",
"\n",
"result",
"[",
"len",
"(",
"result",
")",
"-",
"1",
"]",
".",
"MoreChanges",
"=",
"false",
"\n",
"return",
"result",
",",
"moreChanges",
",",
"nil",
"\n",
"}"
] | // ChangeQuery returns a list of Gerrit changes for a given ChangeQueryParams.
//
// One example use case for this is getting the CL for a given commit hash.
// Only the .Query property of the qr parameter is required.
//
// Returns a slice of Change, whether there are more changes to fetch
// and an error. | [
"ChangeQuery",
"returns",
"a",
"list",
"of",
"Gerrit",
"changes",
"for",
"a",
"given",
"ChangeQueryParams",
".",
"One",
"example",
"use",
"case",
"for",
"this",
"is",
"getting",
"the",
"CL",
"for",
"a",
"given",
"commit",
"hash",
".",
"Only",
"the",
".",
"Query",
"property",
"of",
"the",
"qr",
"parameter",
"is",
"required",
".",
"Returns",
"a",
"slice",
"of",
"Change",
"whether",
"there",
"are",
"more",
"changes",
"to",
"fetch",
"and",
"an",
"error",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/api/gerrit/gerrit.go#L336-L350 |
8,772 | luci/luci-go | common/api/gerrit/gerrit.go | queryString | func (qr *ChangeDetailsParams) queryString() url.Values {
qs := make(url.Values, len(qr.Options))
for _, o := range qr.Options {
qs.Add("o", o)
}
return qs
} | go | func (qr *ChangeDetailsParams) queryString() url.Values {
qs := make(url.Values, len(qr.Options))
for _, o := range qr.Options {
qs.Add("o", o)
}
return qs
} | [
"func",
"(",
"qr",
"*",
"ChangeDetailsParams",
")",
"queryString",
"(",
")",
"url",
".",
"Values",
"{",
"qs",
":=",
"make",
"(",
"url",
".",
"Values",
",",
"len",
"(",
"qr",
".",
"Options",
")",
")",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"qr",
".",
"Options",
"{",
"qs",
".",
"Add",
"(",
"\"",
"\"",
",",
"o",
")",
"\n",
"}",
"\n",
"return",
"qs",
"\n",
"}"
] | // queryString renders the ChangeDetailsParams as a url.Values. | [
"queryString",
"renders",
"the",
"ChangeDetailsParams",
"as",
"a",
"url",
".",
"Values",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/api/gerrit/gerrit.go#L364-L370 |
8,773 | luci/luci-go | common/api/gerrit/gerrit.go | CreateChange | func (c *Client) CreateChange(ctx context.Context, ci *ChangeInput) (*Change, error) {
var resp Change
if _, err := c.post(ctx, "a/changes/", ci, &resp); err != nil {
return nil, err
}
return &resp, nil
} | go | func (c *Client) CreateChange(ctx context.Context, ci *ChangeInput) (*Change, error) {
var resp Change
if _, err := c.post(ctx, "a/changes/", ci, &resp); err != nil {
return nil, err
}
return &resp, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateChange",
"(",
"ctx",
"context",
".",
"Context",
",",
"ci",
"*",
"ChangeInput",
")",
"(",
"*",
"Change",
",",
"error",
")",
"{",
"var",
"resp",
"Change",
"\n",
"if",
"_",
",",
"err",
":=",
"c",
".",
"post",
"(",
"ctx",
",",
"\"",
"\"",
",",
"ci",
",",
"&",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"resp",
",",
"nil",
"\n",
"}"
] | // CreateChange creates a new change in Gerrit.
//
// Returns a Change describing the newly created change or an error. | [
"CreateChange",
"creates",
"a",
"new",
"change",
"in",
"Gerrit",
".",
"Returns",
"a",
"Change",
"describing",
"the",
"newly",
"created",
"change",
"or",
"an",
"error",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/api/gerrit/gerrit.go#L446-L452 |
8,774 | luci/luci-go | milo/buildsource/buildbot/buildstore/query.go | GetBuilds | func GetBuilds(c context.Context, q Query) (*QueryResult, error) {
switch {
case q.Master == "":
return nil, errors.New("master is required")
case q.Builder == "":
return nil, errors.New("builder is required")
}
if !EmulationEnabled(c) {
return getDatastoreBuilds(c, q, true)
}
var emulatedBuilds, buildbotBuilds []*buildbot.Build
err := parallel.FanOutIn(func(work chan<- func() error) {
work <- func() (err error) {
res, err := getDatastoreBuilds(c, q, false)
if res != nil {
buildbotBuilds = res.Builds
}
return
}
work <- func() (err error) {
emulatedBuilds, err = getEmulatedBuilds(c, q)
return
}
})
if err != nil {
return nil, errors.Annotate(err, "could not load builds").Err()
}
mergedBuilds := mergeBuilds(emulatedBuilds, buildbotBuilds)
if q.Limit > 0 && len(mergedBuilds) > q.Limit {
mergedBuilds = mergedBuilds[:q.Limit]
}
return &QueryResult{Builds: mergedBuilds}, nil
} | go | func GetBuilds(c context.Context, q Query) (*QueryResult, error) {
switch {
case q.Master == "":
return nil, errors.New("master is required")
case q.Builder == "":
return nil, errors.New("builder is required")
}
if !EmulationEnabled(c) {
return getDatastoreBuilds(c, q, true)
}
var emulatedBuilds, buildbotBuilds []*buildbot.Build
err := parallel.FanOutIn(func(work chan<- func() error) {
work <- func() (err error) {
res, err := getDatastoreBuilds(c, q, false)
if res != nil {
buildbotBuilds = res.Builds
}
return
}
work <- func() (err error) {
emulatedBuilds, err = getEmulatedBuilds(c, q)
return
}
})
if err != nil {
return nil, errors.Annotate(err, "could not load builds").Err()
}
mergedBuilds := mergeBuilds(emulatedBuilds, buildbotBuilds)
if q.Limit > 0 && len(mergedBuilds) > q.Limit {
mergedBuilds = mergedBuilds[:q.Limit]
}
return &QueryResult{Builds: mergedBuilds}, nil
} | [
"func",
"GetBuilds",
"(",
"c",
"context",
".",
"Context",
",",
"q",
"Query",
")",
"(",
"*",
"QueryResult",
",",
"error",
")",
"{",
"switch",
"{",
"case",
"q",
".",
"Master",
"==",
"\"",
"\"",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"case",
"q",
".",
"Builder",
"==",
"\"",
"\"",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"EmulationEnabled",
"(",
"c",
")",
"{",
"return",
"getDatastoreBuilds",
"(",
"c",
",",
"q",
",",
"true",
")",
"\n",
"}",
"\n\n",
"var",
"emulatedBuilds",
",",
"buildbotBuilds",
"[",
"]",
"*",
"buildbot",
".",
"Build",
"\n",
"err",
":=",
"parallel",
".",
"FanOutIn",
"(",
"func",
"(",
"work",
"chan",
"<-",
"func",
"(",
")",
"error",
")",
"{",
"work",
"<-",
"func",
"(",
")",
"(",
"err",
"error",
")",
"{",
"res",
",",
"err",
":=",
"getDatastoreBuilds",
"(",
"c",
",",
"q",
",",
"false",
")",
"\n",
"if",
"res",
"!=",
"nil",
"{",
"buildbotBuilds",
"=",
"res",
".",
"Builds",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"work",
"<-",
"func",
"(",
")",
"(",
"err",
"error",
")",
"{",
"emulatedBuilds",
",",
"err",
"=",
"getEmulatedBuilds",
"(",
"c",
",",
"q",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n\n",
"mergedBuilds",
":=",
"mergeBuilds",
"(",
"emulatedBuilds",
",",
"buildbotBuilds",
")",
"\n",
"if",
"q",
".",
"Limit",
">",
"0",
"&&",
"len",
"(",
"mergedBuilds",
")",
">",
"q",
".",
"Limit",
"{",
"mergedBuilds",
"=",
"mergedBuilds",
"[",
":",
"q",
".",
"Limit",
"]",
"\n",
"}",
"\n",
"return",
"&",
"QueryResult",
"{",
"Builds",
":",
"mergedBuilds",
"}",
",",
"nil",
"\n",
"}"
] | // GetBuilds executes a build query and returns results.
// Does not check access. | [
"GetBuilds",
"executes",
"a",
"build",
"query",
"and",
"returns",
"results",
".",
"Does",
"not",
"check",
"access",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/query.go#L112-L147 |
8,775 | luci/luci-go | milo/buildsource/buildbot/buildstore/query.go | mergeBuilds | func mergeBuilds(a, b []*buildbot.Build) []*buildbot.Build {
ret := make([]*buildbot.Build, len(a), len(a)+len(b))
copy(ret, a)
// add builds from b that have unique build numbers.
aNumbers := make(map[int]struct{}, len(a))
for _, build := range a {
aNumbers[build.Number] = struct{}{}
}
for _, build := range b {
if _, ok := aNumbers[build.Number]; !ok {
ret = append(ret, build)
}
}
sort.Slice(ret, func(i, j int) bool {
return ret[i].Number > ret[j].Number
})
return ret
} | go | func mergeBuilds(a, b []*buildbot.Build) []*buildbot.Build {
ret := make([]*buildbot.Build, len(a), len(a)+len(b))
copy(ret, a)
// add builds from b that have unique build numbers.
aNumbers := make(map[int]struct{}, len(a))
for _, build := range a {
aNumbers[build.Number] = struct{}{}
}
for _, build := range b {
if _, ok := aNumbers[build.Number]; !ok {
ret = append(ret, build)
}
}
sort.Slice(ret, func(i, j int) bool {
return ret[i].Number > ret[j].Number
})
return ret
} | [
"func",
"mergeBuilds",
"(",
"a",
",",
"b",
"[",
"]",
"*",
"buildbot",
".",
"Build",
")",
"[",
"]",
"*",
"buildbot",
".",
"Build",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"*",
"buildbot",
".",
"Build",
",",
"len",
"(",
"a",
")",
",",
"len",
"(",
"a",
")",
"+",
"len",
"(",
"b",
")",
")",
"\n",
"copy",
"(",
"ret",
",",
"a",
")",
"\n\n",
"// add builds from b that have unique build numbers.",
"aNumbers",
":=",
"make",
"(",
"map",
"[",
"int",
"]",
"struct",
"{",
"}",
",",
"len",
"(",
"a",
")",
")",
"\n",
"for",
"_",
",",
"build",
":=",
"range",
"a",
"{",
"aNumbers",
"[",
"build",
".",
"Number",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"build",
":=",
"range",
"b",
"{",
"if",
"_",
",",
"ok",
":=",
"aNumbers",
"[",
"build",
".",
"Number",
"]",
";",
"!",
"ok",
"{",
"ret",
"=",
"append",
"(",
"ret",
",",
"build",
")",
"\n",
"}",
"\n",
"}",
"\n",
"sort",
".",
"Slice",
"(",
"ret",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"ret",
"[",
"i",
"]",
".",
"Number",
">",
"ret",
"[",
"j",
"]",
".",
"Number",
"\n",
"}",
")",
"\n",
"return",
"ret",
"\n",
"}"
] | // mergeBuilds merges builds from a and b to one slice.
// The returned builds are ordered by build numbers, descending.
//
// If a build number is present in both a and b, b's build is ignored. | [
"mergeBuilds",
"merges",
"builds",
"from",
"a",
"and",
"b",
"to",
"one",
"slice",
".",
"The",
"returned",
"builds",
"are",
"ordered",
"by",
"build",
"numbers",
"descending",
".",
"If",
"a",
"build",
"number",
"is",
"present",
"in",
"both",
"a",
"and",
"b",
"b",
"s",
"build",
"is",
"ignored",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/milo/buildsource/buildbot/buildstore/query.go#L153-L171 |
8,776 | luci/luci-go | scheduler/appengine/task/utils/kvlist.go | ValidateKVList | func ValidateKVList(kind string, list []string, sep rune) error {
for _, item := range list {
if !strings.ContainsRune(item, sep) {
return fmt.Errorf("bad %s, not a 'key%svalue' pair: %q", kind, string(sep), item)
}
}
return nil
} | go | func ValidateKVList(kind string, list []string, sep rune) error {
for _, item := range list {
if !strings.ContainsRune(item, sep) {
return fmt.Errorf("bad %s, not a 'key%svalue' pair: %q", kind, string(sep), item)
}
}
return nil
} | [
"func",
"ValidateKVList",
"(",
"kind",
"string",
",",
"list",
"[",
"]",
"string",
",",
"sep",
"rune",
")",
"error",
"{",
"for",
"_",
",",
"item",
":=",
"range",
"list",
"{",
"if",
"!",
"strings",
".",
"ContainsRune",
"(",
"item",
",",
"sep",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"kind",
",",
"string",
"(",
"sep",
")",
",",
"item",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ValidateKVList makes sure each string in the list is valid key-value pair. | [
"ValidateKVList",
"makes",
"sure",
"each",
"string",
"in",
"the",
"list",
"is",
"valid",
"key",
"-",
"value",
"pair",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/scheduler/appengine/task/utils/kvlist.go#L33-L40 |
8,777 | luci/luci-go | scheduler/appengine/task/utils/kvlist.go | KVListFromMap | func KVListFromMap(m map[string]string) KVList {
keys := make([]string, 0, len(m))
for k := range m {
keys = append(keys, k)
}
sort.Strings(keys)
kvList := make([]KV, len(keys))
for i, k := range keys {
kvList[i] = KV{
Key: k,
Value: m[k],
}
}
return kvList
} | go | func KVListFromMap(m map[string]string) KVList {
keys := make([]string, 0, len(m))
for k := range m {
keys = append(keys, k)
}
sort.Strings(keys)
kvList := make([]KV, len(keys))
for i, k := range keys {
kvList[i] = KV{
Key: k,
Value: m[k],
}
}
return kvList
} | [
"func",
"KVListFromMap",
"(",
"m",
"map",
"[",
"string",
"]",
"string",
")",
"KVList",
"{",
"keys",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"m",
")",
")",
"\n",
"for",
"k",
":=",
"range",
"m",
"{",
"keys",
"=",
"append",
"(",
"keys",
",",
"k",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"keys",
")",
"\n",
"kvList",
":=",
"make",
"(",
"[",
"]",
"KV",
",",
"len",
"(",
"keys",
")",
")",
"\n",
"for",
"i",
",",
"k",
":=",
"range",
"keys",
"{",
"kvList",
"[",
"i",
"]",
"=",
"KV",
"{",
"Key",
":",
"k",
",",
"Value",
":",
"m",
"[",
"k",
"]",
",",
"}",
"\n",
"}",
"\n",
"return",
"kvList",
"\n",
"}"
] | // KVListFromMap converts a map to KVList. | [
"KVListFromMap",
"converts",
"a",
"map",
"to",
"KVList",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/scheduler/appengine/task/utils/kvlist.go#L43-L57 |
8,778 | luci/luci-go | scheduler/appengine/task/utils/kvlist.go | UnpackKVList | func UnpackKVList(list []string, sep rune) (out KVList) {
for _, item := range list {
idx := strings.IndexRune(item, sep)
if idx == -1 {
continue
}
out = append(out, KV{
Key: item[:idx],
Value: item[idx+1:],
})
}
return out
} | go | func UnpackKVList(list []string, sep rune) (out KVList) {
for _, item := range list {
idx := strings.IndexRune(item, sep)
if idx == -1 {
continue
}
out = append(out, KV{
Key: item[:idx],
Value: item[idx+1:],
})
}
return out
} | [
"func",
"UnpackKVList",
"(",
"list",
"[",
"]",
"string",
",",
"sep",
"rune",
")",
"(",
"out",
"KVList",
")",
"{",
"for",
"_",
",",
"item",
":=",
"range",
"list",
"{",
"idx",
":=",
"strings",
".",
"IndexRune",
"(",
"item",
",",
"sep",
")",
"\n",
"if",
"idx",
"==",
"-",
"1",
"{",
"continue",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"KV",
"{",
"Key",
":",
"item",
"[",
":",
"idx",
"]",
",",
"Value",
":",
"item",
"[",
"idx",
"+",
"1",
":",
"]",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // UnpackKVList takes validated list of k-v pair strings and returns list of
// structs.
//
// Silently skips malformed strings. Use ValidateKVList to detect them before
// calling this function. | [
"UnpackKVList",
"takes",
"validated",
"list",
"of",
"k",
"-",
"v",
"pair",
"strings",
"and",
"returns",
"list",
"of",
"structs",
".",
"Silently",
"skips",
"malformed",
"strings",
".",
"Use",
"ValidateKVList",
"to",
"detect",
"them",
"before",
"calling",
"this",
"function",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/scheduler/appengine/task/utils/kvlist.go#L64-L76 |
8,779 | luci/luci-go | scheduler/appengine/task/utils/kvlist.go | Pack | func (l KVList) Pack(sep rune) []string {
out := make([]string, len(l))
for i, kv := range l {
out[i] = kv.Key + string(sep) + kv.Value
}
return out
} | go | func (l KVList) Pack(sep rune) []string {
out := make([]string, len(l))
for i, kv := range l {
out[i] = kv.Key + string(sep) + kv.Value
}
return out
} | [
"func",
"(",
"l",
"KVList",
")",
"Pack",
"(",
"sep",
"rune",
")",
"[",
"]",
"string",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"l",
")",
")",
"\n",
"for",
"i",
",",
"kv",
":=",
"range",
"l",
"{",
"out",
"[",
"i",
"]",
"=",
"kv",
".",
"Key",
"+",
"string",
"(",
"sep",
")",
"+",
"kv",
".",
"Value",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // Pack converts KV list to a list of strings. | [
"Pack",
"converts",
"KV",
"list",
"to",
"a",
"list",
"of",
"strings",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/scheduler/appengine/task/utils/kvlist.go#L79-L85 |
8,780 | luci/luci-go | scheduler/appengine/engine/dsset/dsset.go | makeTombstonesEntity | func (p *PopOp) makeTombstonesEntity() *tombstonesEntity {
p.entity.Tombstones = p.entity.Tombstones[:0]
for id, ts := range p.tombs {
p.entity.Tombstones = append(p.entity.Tombstones, struct {
ID string
Tombstoned time.Time
}{id, ts})
}
return p.entity
} | go | func (p *PopOp) makeTombstonesEntity() *tombstonesEntity {
p.entity.Tombstones = p.entity.Tombstones[:0]
for id, ts := range p.tombs {
p.entity.Tombstones = append(p.entity.Tombstones, struct {
ID string
Tombstoned time.Time
}{id, ts})
}
return p.entity
} | [
"func",
"(",
"p",
"*",
"PopOp",
")",
"makeTombstonesEntity",
"(",
")",
"*",
"tombstonesEntity",
"{",
"p",
".",
"entity",
".",
"Tombstones",
"=",
"p",
".",
"entity",
".",
"Tombstones",
"[",
":",
"0",
"]",
"\n",
"for",
"id",
",",
"ts",
":=",
"range",
"p",
".",
"tombs",
"{",
"p",
".",
"entity",
".",
"Tombstones",
"=",
"append",
"(",
"p",
".",
"entity",
".",
"Tombstones",
",",
"struct",
"{",
"ID",
"string",
"\n",
"Tombstoned",
"time",
".",
"Time",
"\n",
"}",
"{",
"id",
",",
"ts",
"}",
")",
"\n",
"}",
"\n",
"return",
"p",
".",
"entity",
"\n",
"}"
] | // makeTombstonesEntity is used internally by FinishPop. | [
"makeTombstonesEntity",
"is",
"used",
"internally",
"by",
"FinishPop",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/scheduler/appengine/engine/dsset/dsset.go#L405-L414 |
8,781 | luci/luci-go | scheduler/appengine/engine/dsset/dsset.go | shardRoot | func (s *Set) shardRoot(c context.Context, n int) *datastore.Key {
return datastore.NewKey(c, "dsset.Shard", fmt.Sprintf("%s:%d", s.ID, n), 0, nil)
} | go | func (s *Set) shardRoot(c context.Context, n int) *datastore.Key {
return datastore.NewKey(c, "dsset.Shard", fmt.Sprintf("%s:%d", s.ID, n), 0, nil)
} | [
"func",
"(",
"s",
"*",
"Set",
")",
"shardRoot",
"(",
"c",
"context",
".",
"Context",
",",
"n",
"int",
")",
"*",
"datastore",
".",
"Key",
"{",
"return",
"datastore",
".",
"NewKey",
"(",
"c",
",",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
".",
"ID",
",",
"n",
")",
",",
"0",
",",
"nil",
")",
"\n",
"}"
] | // shardRoot returns entity group key to use for a given shard. | [
"shardRoot",
"returns",
"entity",
"group",
"key",
"to",
"use",
"for",
"a",
"given",
"shard",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/scheduler/appengine/engine/dsset/dsset.go#L529-L531 |
8,782 | luci/luci-go | scheduler/appengine/engine/dsset/dsset.go | batchOp | func batchOp(total int, op func(start, end int) error) error {
switch {
case total == 0:
return nil
case total <= batchSize:
return op(0, total)
}
errs := make(chan error)
ops := 0
offset := 0
for total > 0 {
count := batchSize
if count > total {
count = total
}
go func(start, end int) {
errs <- op(start, end)
}(offset, offset+count)
offset += count
total -= count
ops++
}
var all errors.MultiError
for i := 0; i < ops; i++ {
err := <-errs
if merr, yep := err.(errors.MultiError); yep {
for _, e := range merr {
if e != nil {
all = append(all, e)
}
}
} else if err != nil {
all = append(all, err)
}
}
if len(all) == 0 {
return nil
}
return all
} | go | func batchOp(total int, op func(start, end int) error) error {
switch {
case total == 0:
return nil
case total <= batchSize:
return op(0, total)
}
errs := make(chan error)
ops := 0
offset := 0
for total > 0 {
count := batchSize
if count > total {
count = total
}
go func(start, end int) {
errs <- op(start, end)
}(offset, offset+count)
offset += count
total -= count
ops++
}
var all errors.MultiError
for i := 0; i < ops; i++ {
err := <-errs
if merr, yep := err.(errors.MultiError); yep {
for _, e := range merr {
if e != nil {
all = append(all, e)
}
}
} else if err != nil {
all = append(all, err)
}
}
if len(all) == 0 {
return nil
}
return all
} | [
"func",
"batchOp",
"(",
"total",
"int",
",",
"op",
"func",
"(",
"start",
",",
"end",
"int",
")",
"error",
")",
"error",
"{",
"switch",
"{",
"case",
"total",
"==",
"0",
":",
"return",
"nil",
"\n",
"case",
"total",
"<=",
"batchSize",
":",
"return",
"op",
"(",
"0",
",",
"total",
")",
"\n",
"}",
"\n\n",
"errs",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"ops",
":=",
"0",
"\n",
"offset",
":=",
"0",
"\n",
"for",
"total",
">",
"0",
"{",
"count",
":=",
"batchSize",
"\n",
"if",
"count",
">",
"total",
"{",
"count",
"=",
"total",
"\n",
"}",
"\n",
"go",
"func",
"(",
"start",
",",
"end",
"int",
")",
"{",
"errs",
"<-",
"op",
"(",
"start",
",",
"end",
")",
"\n",
"}",
"(",
"offset",
",",
"offset",
"+",
"count",
")",
"\n",
"offset",
"+=",
"count",
"\n",
"total",
"-=",
"count",
"\n",
"ops",
"++",
"\n",
"}",
"\n\n",
"var",
"all",
"errors",
".",
"MultiError",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"ops",
";",
"i",
"++",
"{",
"err",
":=",
"<-",
"errs",
"\n",
"if",
"merr",
",",
"yep",
":=",
"err",
".",
"(",
"errors",
".",
"MultiError",
")",
";",
"yep",
"{",
"for",
"_",
",",
"e",
":=",
"range",
"merr",
"{",
"if",
"e",
"!=",
"nil",
"{",
"all",
"=",
"append",
"(",
"all",
",",
"e",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"all",
"=",
"append",
"(",
"all",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"all",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"all",
"\n",
"}"
] | // batchOp splits 'total' into batches and calls 'op' in parallel.
//
// Doesn't preserve order of returned errors! Don't try to deconstruct the
// returned multi error, the position of individual errors there does not
// correlate with the original array. | [
"batchOp",
"splits",
"total",
"into",
"batches",
"and",
"calls",
"op",
"in",
"parallel",
".",
"Doesn",
"t",
"preserve",
"order",
"of",
"returned",
"errors!",
"Don",
"t",
"try",
"to",
"deconstruct",
"the",
"returned",
"multi",
"error",
"the",
"position",
"of",
"individual",
"errors",
"there",
"does",
"not",
"correlate",
"with",
"the",
"original",
"array",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/scheduler/appengine/engine/dsset/dsset.go#L538-L580 |
8,783 | luci/luci-go | buildbucket/cli/cl.go | retrieveCLs | func (f *clsFlag) retrieveCLs(ctx context.Context, httpClient *http.Client, requirePatchset bool) ([]*pb.GerritChange, error) {
ret := make([]*pb.GerritChange, len(f.cls))
return ret, parallel.FanOutIn(func(work chan<- func() error) {
for i, cl := range f.cls {
i := i
work <- func() error {
change, err := f.retrieveCL(ctx, cl, httpClient, requirePatchset)
if err != nil {
return fmt.Errorf("CL %q: %s", cl, err)
}
ret[i] = change
return nil
}
}
})
} | go | func (f *clsFlag) retrieveCLs(ctx context.Context, httpClient *http.Client, requirePatchset bool) ([]*pb.GerritChange, error) {
ret := make([]*pb.GerritChange, len(f.cls))
return ret, parallel.FanOutIn(func(work chan<- func() error) {
for i, cl := range f.cls {
i := i
work <- func() error {
change, err := f.retrieveCL(ctx, cl, httpClient, requirePatchset)
if err != nil {
return fmt.Errorf("CL %q: %s", cl, err)
}
ret[i] = change
return nil
}
}
})
} | [
"func",
"(",
"f",
"*",
"clsFlag",
")",
"retrieveCLs",
"(",
"ctx",
"context",
".",
"Context",
",",
"httpClient",
"*",
"http",
".",
"Client",
",",
"requirePatchset",
"bool",
")",
"(",
"[",
"]",
"*",
"pb",
".",
"GerritChange",
",",
"error",
")",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"*",
"pb",
".",
"GerritChange",
",",
"len",
"(",
"f",
".",
"cls",
")",
")",
"\n",
"return",
"ret",
",",
"parallel",
".",
"FanOutIn",
"(",
"func",
"(",
"work",
"chan",
"<-",
"func",
"(",
")",
"error",
")",
"{",
"for",
"i",
",",
"cl",
":=",
"range",
"f",
".",
"cls",
"{",
"i",
":=",
"i",
"\n",
"work",
"<-",
"func",
"(",
")",
"error",
"{",
"change",
",",
"err",
":=",
"f",
".",
"retrieveCL",
"(",
"ctx",
",",
"cl",
",",
"httpClient",
",",
"requirePatchset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cl",
",",
"err",
")",
"\n",
"}",
"\n",
"ret",
"[",
"i",
"]",
"=",
"change",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}"
] | // retrieveCLs retrieves GerritChange objects from f.cls.
// Makes Gerrit RPCs if necessary, in parallel. | [
"retrieveCLs",
"retrieves",
"GerritChange",
"objects",
"from",
"f",
".",
"cls",
".",
"Makes",
"Gerrit",
"RPCs",
"if",
"necessary",
"in",
"parallel",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/buildbucket/cli/cl.go#L45-L60 |
8,784 | luci/luci-go | buildbucket/cli/cl.go | retrieveCL | func (f *clsFlag) retrieveCL(ctx context.Context, cl string, httpClient *http.Client, requirePatchset bool) (*pb.GerritChange, error) {
ret, err := parseCL(cl)
switch {
case err != nil:
return nil, err
case requirePatchset && ret.Patchset == 0:
return nil, fmt.Errorf("missing patchset number")
case ret.Project != "" && ret.Patchset != 0:
return ret, nil
}
// Fetch CL info from Gerrit.
client, err := gerrit.NewRESTClient(httpClient, ret.Host, true)
if err != nil {
return nil, err
}
change, err := client.GetChange(ctx, &gerritpb.GetChangeRequest{
Number: ret.Change,
Options: []gerritpb.QueryOption{gerritpb.QueryOption_CURRENT_REVISION},
})
if err != nil {
return nil, fmt.Errorf("failed to fetch CL %d from %q: %s", ret.Change, ret.Host, err)
}
ret.Project = change.Project
if ret.Patchset == 0 {
ret.Patchset = int64(change.Revisions[change.CurrentRevision].Number)
}
return ret, nil
} | go | func (f *clsFlag) retrieveCL(ctx context.Context, cl string, httpClient *http.Client, requirePatchset bool) (*pb.GerritChange, error) {
ret, err := parseCL(cl)
switch {
case err != nil:
return nil, err
case requirePatchset && ret.Patchset == 0:
return nil, fmt.Errorf("missing patchset number")
case ret.Project != "" && ret.Patchset != 0:
return ret, nil
}
// Fetch CL info from Gerrit.
client, err := gerrit.NewRESTClient(httpClient, ret.Host, true)
if err != nil {
return nil, err
}
change, err := client.GetChange(ctx, &gerritpb.GetChangeRequest{
Number: ret.Change,
Options: []gerritpb.QueryOption{gerritpb.QueryOption_CURRENT_REVISION},
})
if err != nil {
return nil, fmt.Errorf("failed to fetch CL %d from %q: %s", ret.Change, ret.Host, err)
}
ret.Project = change.Project
if ret.Patchset == 0 {
ret.Patchset = int64(change.Revisions[change.CurrentRevision].Number)
}
return ret, nil
} | [
"func",
"(",
"f",
"*",
"clsFlag",
")",
"retrieveCL",
"(",
"ctx",
"context",
".",
"Context",
",",
"cl",
"string",
",",
"httpClient",
"*",
"http",
".",
"Client",
",",
"requirePatchset",
"bool",
")",
"(",
"*",
"pb",
".",
"GerritChange",
",",
"error",
")",
"{",
"ret",
",",
"err",
":=",
"parseCL",
"(",
"cl",
")",
"\n",
"switch",
"{",
"case",
"err",
"!=",
"nil",
":",
"return",
"nil",
",",
"err",
"\n",
"case",
"requirePatchset",
"&&",
"ret",
".",
"Patchset",
"==",
"0",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"case",
"ret",
".",
"Project",
"!=",
"\"",
"\"",
"&&",
"ret",
".",
"Patchset",
"!=",
"0",
":",
"return",
"ret",
",",
"nil",
"\n",
"}",
"\n\n",
"// Fetch CL info from Gerrit.",
"client",
",",
"err",
":=",
"gerrit",
".",
"NewRESTClient",
"(",
"httpClient",
",",
"ret",
".",
"Host",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"change",
",",
"err",
":=",
"client",
".",
"GetChange",
"(",
"ctx",
",",
"&",
"gerritpb",
".",
"GetChangeRequest",
"{",
"Number",
":",
"ret",
".",
"Change",
",",
"Options",
":",
"[",
"]",
"gerritpb",
".",
"QueryOption",
"{",
"gerritpb",
".",
"QueryOption_CURRENT_REVISION",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ret",
".",
"Change",
",",
"ret",
".",
"Host",
",",
"err",
")",
"\n",
"}",
"\n\n",
"ret",
".",
"Project",
"=",
"change",
".",
"Project",
"\n",
"if",
"ret",
".",
"Patchset",
"==",
"0",
"{",
"ret",
".",
"Patchset",
"=",
"int64",
"(",
"change",
".",
"Revisions",
"[",
"change",
".",
"CurrentRevision",
"]",
".",
"Number",
")",
"\n",
"}",
"\n",
"return",
"ret",
",",
"nil",
"\n",
"}"
] | // retrieveCL retrieves a GerritChange from a string.
// Makes a Gerrit RPC if necessary. | [
"retrieveCL",
"retrieves",
"a",
"GerritChange",
"from",
"a",
"string",
".",
"Makes",
"a",
"Gerrit",
"RPC",
"if",
"necessary",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/buildbucket/cli/cl.go#L64-L93 |
8,785 | luci/luci-go | machine-db/appengine/model/ips.go | fetch | func (t *IPsTable) fetch(c context.Context) error {
db := database.Get(c)
rows, err := db.QueryContext(c, `
SELECT id, ipv4, vlan_id
FROM ips
`)
if err != nil {
return errors.Annotate(err, "failed to select IP addresses").Err()
}
defer rows.Close()
for rows.Next() {
ip := &IP{}
if err := rows.Scan(&ip.Id, &ip.IPv4, &ip.VLANId); err != nil {
return errors.Annotate(err, "failed to scan IP address").Err()
}
t.current = append(t.current, ip)
}
return nil
} | go | func (t *IPsTable) fetch(c context.Context) error {
db := database.Get(c)
rows, err := db.QueryContext(c, `
SELECT id, ipv4, vlan_id
FROM ips
`)
if err != nil {
return errors.Annotate(err, "failed to select IP addresses").Err()
}
defer rows.Close()
for rows.Next() {
ip := &IP{}
if err := rows.Scan(&ip.Id, &ip.IPv4, &ip.VLANId); err != nil {
return errors.Annotate(err, "failed to scan IP address").Err()
}
t.current = append(t.current, ip)
}
return nil
} | [
"func",
"(",
"t",
"*",
"IPsTable",
")",
"fetch",
"(",
"c",
"context",
".",
"Context",
")",
"error",
"{",
"db",
":=",
"database",
".",
"Get",
"(",
"c",
")",
"\n",
"rows",
",",
"err",
":=",
"db",
".",
"QueryContext",
"(",
"c",
",",
"`\n\t\tSELECT id, ipv4, vlan_id\n\t\tFROM ips\n\t`",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"defer",
"rows",
".",
"Close",
"(",
")",
"\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"ip",
":=",
"&",
"IP",
"{",
"}",
"\n",
"if",
"err",
":=",
"rows",
".",
"Scan",
"(",
"&",
"ip",
".",
"Id",
",",
"&",
"ip",
".",
"IPv4",
",",
"&",
"ip",
".",
"VLANId",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"t",
".",
"current",
"=",
"append",
"(",
"t",
".",
"current",
",",
"ip",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // fetch fetches the IP addresses from the database. | [
"fetch",
"fetches",
"the",
"IP",
"addresses",
"from",
"the",
"database",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/machine-db/appengine/model/ips.go#L49-L67 |
8,786 | luci/luci-go | machine-db/appengine/model/ips.go | computeChanges | func (t *IPsTable) computeChanges(c context.Context, vlans []*config.VLAN) error {
cfgs := make(map[common.IPv4]*IP, len(vlans))
for _, vlan := range vlans {
ipv4, length, err := common.IPv4Range(vlan.CidrBlock)
if err != nil {
return errors.Annotate(err, "failed to determine start address and range for CIDR block %q", vlan.CidrBlock).Err()
}
// TODO(smut): Mark the first address as the network address and the last address as the broadcast address.
for i := int64(0); i < length; i++ {
cfgs[ipv4] = &IP{
IPv4: ipv4,
VLANId: vlan.Id,
}
ipv4 += 1
}
}
for _, ip := range t.current {
if cfg, ok := cfgs[ip.IPv4]; ok {
// IP address found in the config.
if t.needsUpdate(ip, cfg) {
// IP address doesn't match the config.
cfg.Id = ip.Id
t.updates = append(t.updates, cfg)
}
// Record that the IP address config has been seen.
delete(cfgs, cfg.IPv4)
} else {
// IP address not found in the config.
t.removals = append(t.removals, ip)
}
}
// IP addresses remaining in the map are present in the config but not the database.
// Iterate deterministically over the slices to determine which IP addresses need to be added.
for _, vlan := range vlans {
ipv4, length, err := common.IPv4Range(vlan.CidrBlock)
if err != nil {
return errors.Annotate(err, "failed to determine start address and range for CIDR block %q", vlan.CidrBlock).Err()
}
for i := int64(0); i < length; i++ {
if ip, ok := cfgs[ipv4]; ok {
t.additions = append(t.additions, ip)
}
ipv4 += 1
}
}
return nil
} | go | func (t *IPsTable) computeChanges(c context.Context, vlans []*config.VLAN) error {
cfgs := make(map[common.IPv4]*IP, len(vlans))
for _, vlan := range vlans {
ipv4, length, err := common.IPv4Range(vlan.CidrBlock)
if err != nil {
return errors.Annotate(err, "failed to determine start address and range for CIDR block %q", vlan.CidrBlock).Err()
}
// TODO(smut): Mark the first address as the network address and the last address as the broadcast address.
for i := int64(0); i < length; i++ {
cfgs[ipv4] = &IP{
IPv4: ipv4,
VLANId: vlan.Id,
}
ipv4 += 1
}
}
for _, ip := range t.current {
if cfg, ok := cfgs[ip.IPv4]; ok {
// IP address found in the config.
if t.needsUpdate(ip, cfg) {
// IP address doesn't match the config.
cfg.Id = ip.Id
t.updates = append(t.updates, cfg)
}
// Record that the IP address config has been seen.
delete(cfgs, cfg.IPv4)
} else {
// IP address not found in the config.
t.removals = append(t.removals, ip)
}
}
// IP addresses remaining in the map are present in the config but not the database.
// Iterate deterministically over the slices to determine which IP addresses need to be added.
for _, vlan := range vlans {
ipv4, length, err := common.IPv4Range(vlan.CidrBlock)
if err != nil {
return errors.Annotate(err, "failed to determine start address and range for CIDR block %q", vlan.CidrBlock).Err()
}
for i := int64(0); i < length; i++ {
if ip, ok := cfgs[ipv4]; ok {
t.additions = append(t.additions, ip)
}
ipv4 += 1
}
}
return nil
} | [
"func",
"(",
"t",
"*",
"IPsTable",
")",
"computeChanges",
"(",
"c",
"context",
".",
"Context",
",",
"vlans",
"[",
"]",
"*",
"config",
".",
"VLAN",
")",
"error",
"{",
"cfgs",
":=",
"make",
"(",
"map",
"[",
"common",
".",
"IPv4",
"]",
"*",
"IP",
",",
"len",
"(",
"vlans",
")",
")",
"\n",
"for",
"_",
",",
"vlan",
":=",
"range",
"vlans",
"{",
"ipv4",
",",
"length",
",",
"err",
":=",
"common",
".",
"IPv4Range",
"(",
"vlan",
".",
"CidrBlock",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
",",
"vlan",
".",
"CidrBlock",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"// TODO(smut): Mark the first address as the network address and the last address as the broadcast address.",
"for",
"i",
":=",
"int64",
"(",
"0",
")",
";",
"i",
"<",
"length",
";",
"i",
"++",
"{",
"cfgs",
"[",
"ipv4",
"]",
"=",
"&",
"IP",
"{",
"IPv4",
":",
"ipv4",
",",
"VLANId",
":",
"vlan",
".",
"Id",
",",
"}",
"\n",
"ipv4",
"+=",
"1",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ip",
":=",
"range",
"t",
".",
"current",
"{",
"if",
"cfg",
",",
"ok",
":=",
"cfgs",
"[",
"ip",
".",
"IPv4",
"]",
";",
"ok",
"{",
"// IP address found in the config.",
"if",
"t",
".",
"needsUpdate",
"(",
"ip",
",",
"cfg",
")",
"{",
"// IP address doesn't match the config.",
"cfg",
".",
"Id",
"=",
"ip",
".",
"Id",
"\n",
"t",
".",
"updates",
"=",
"append",
"(",
"t",
".",
"updates",
",",
"cfg",
")",
"\n",
"}",
"\n",
"// Record that the IP address config has been seen.",
"delete",
"(",
"cfgs",
",",
"cfg",
".",
"IPv4",
")",
"\n",
"}",
"else",
"{",
"// IP address not found in the config.",
"t",
".",
"removals",
"=",
"append",
"(",
"t",
".",
"removals",
",",
"ip",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// IP addresses remaining in the map are present in the config but not the database.",
"// Iterate deterministically over the slices to determine which IP addresses need to be added.",
"for",
"_",
",",
"vlan",
":=",
"range",
"vlans",
"{",
"ipv4",
",",
"length",
",",
"err",
":=",
"common",
".",
"IPv4Range",
"(",
"vlan",
".",
"CidrBlock",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
",",
"vlan",
".",
"CidrBlock",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"for",
"i",
":=",
"int64",
"(",
"0",
")",
";",
"i",
"<",
"length",
";",
"i",
"++",
"{",
"if",
"ip",
",",
"ok",
":=",
"cfgs",
"[",
"ipv4",
"]",
";",
"ok",
"{",
"t",
".",
"additions",
"=",
"append",
"(",
"t",
".",
"additions",
",",
"ip",
")",
"\n",
"}",
"\n",
"ipv4",
"+=",
"1",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // computeChanges computes the changes that need to be made to the IP addresses in the database. | [
"computeChanges",
"computes",
"the",
"changes",
"that",
"need",
"to",
"be",
"made",
"to",
"the",
"IP",
"addresses",
"in",
"the",
"database",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/machine-db/appengine/model/ips.go#L75-L123 |
8,787 | luci/luci-go | machine-db/appengine/model/ips.go | add | func (t *IPsTable) add(c context.Context) error {
// Avoid using the database connection to prepare unnecessary statements.
if len(t.additions) == 0 {
return nil
}
db := database.Get(c)
stmt, err := db.PrepareContext(c, `
INSERT INTO ips (ipv4, vlan_id)
VALUES (?, ?)
`)
if err != nil {
return errors.Annotate(err, "failed to prepare statement").Err()
}
defer stmt.Close()
// Add each IP address to the database, and update the slice of IP address with each addition.
// TODO(smut): Batch SQL operations if it becomes necessary.
logging.Infof(c, "Attempting to add %d IP addresses", len(t.additions))
for len(t.additions) > 0 {
ip := t.additions[0]
result, err := stmt.ExecContext(c, ip.IPv4, ip.VLANId)
if err != nil {
return errors.Annotate(err, "failed to add IP address %q", ip.IPv4).Err()
}
t.current = append(t.current, ip)
t.additions = t.additions[1:]
logging.Infof(c, "Added IP address %q", ip.IPv4)
ip.Id, err = result.LastInsertId()
if err != nil {
return errors.Annotate(err, "failed to get IP address ID %q", ip.IPv4).Err()
}
}
return nil
} | go | func (t *IPsTable) add(c context.Context) error {
// Avoid using the database connection to prepare unnecessary statements.
if len(t.additions) == 0 {
return nil
}
db := database.Get(c)
stmt, err := db.PrepareContext(c, `
INSERT INTO ips (ipv4, vlan_id)
VALUES (?, ?)
`)
if err != nil {
return errors.Annotate(err, "failed to prepare statement").Err()
}
defer stmt.Close()
// Add each IP address to the database, and update the slice of IP address with each addition.
// TODO(smut): Batch SQL operations if it becomes necessary.
logging.Infof(c, "Attempting to add %d IP addresses", len(t.additions))
for len(t.additions) > 0 {
ip := t.additions[0]
result, err := stmt.ExecContext(c, ip.IPv4, ip.VLANId)
if err != nil {
return errors.Annotate(err, "failed to add IP address %q", ip.IPv4).Err()
}
t.current = append(t.current, ip)
t.additions = t.additions[1:]
logging.Infof(c, "Added IP address %q", ip.IPv4)
ip.Id, err = result.LastInsertId()
if err != nil {
return errors.Annotate(err, "failed to get IP address ID %q", ip.IPv4).Err()
}
}
return nil
} | [
"func",
"(",
"t",
"*",
"IPsTable",
")",
"add",
"(",
"c",
"context",
".",
"Context",
")",
"error",
"{",
"// Avoid using the database connection to prepare unnecessary statements.",
"if",
"len",
"(",
"t",
".",
"additions",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"db",
":=",
"database",
".",
"Get",
"(",
"c",
")",
"\n",
"stmt",
",",
"err",
":=",
"db",
".",
"PrepareContext",
"(",
"c",
",",
"`\n\t\tINSERT INTO ips (ipv4, vlan_id)\n\t\tVALUES (?, ?)\n\t`",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"defer",
"stmt",
".",
"Close",
"(",
")",
"\n\n",
"// Add each IP address to the database, and update the slice of IP address with each addition.",
"// TODO(smut): Batch SQL operations if it becomes necessary.",
"logging",
".",
"Infof",
"(",
"c",
",",
"\"",
"\"",
",",
"len",
"(",
"t",
".",
"additions",
")",
")",
"\n",
"for",
"len",
"(",
"t",
".",
"additions",
")",
">",
"0",
"{",
"ip",
":=",
"t",
".",
"additions",
"[",
"0",
"]",
"\n",
"result",
",",
"err",
":=",
"stmt",
".",
"ExecContext",
"(",
"c",
",",
"ip",
".",
"IPv4",
",",
"ip",
".",
"VLANId",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
",",
"ip",
".",
"IPv4",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"t",
".",
"current",
"=",
"append",
"(",
"t",
".",
"current",
",",
"ip",
")",
"\n",
"t",
".",
"additions",
"=",
"t",
".",
"additions",
"[",
"1",
":",
"]",
"\n",
"logging",
".",
"Infof",
"(",
"c",
",",
"\"",
"\"",
",",
"ip",
".",
"IPv4",
")",
"\n",
"ip",
".",
"Id",
",",
"err",
"=",
"result",
".",
"LastInsertId",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
",",
"ip",
".",
"IPv4",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // add adds all IP addresses pending addition to the database, clearing pending additions.
// No-op unless computeChanges was called first. Idempotent until computeChanges is called again. | [
"add",
"adds",
"all",
"IP",
"addresses",
"pending",
"addition",
"to",
"the",
"database",
"clearing",
"pending",
"additions",
".",
"No",
"-",
"op",
"unless",
"computeChanges",
"was",
"called",
"first",
".",
"Idempotent",
"until",
"computeChanges",
"is",
"called",
"again",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/machine-db/appengine/model/ips.go#L127-L161 |
8,788 | luci/luci-go | machine-db/appengine/model/ips.go | remove | func (t *IPsTable) remove(c context.Context) error {
// Avoid using the database connection to prepare unnecessary statements.
if len(t.removals) == 0 {
return nil
}
db := database.Get(c)
stmt, err := db.PrepareContext(c, `
DELETE FROM ips
WHERE id = ?
`)
if err != nil {
return errors.Annotate(err, "failed to prepare statement").Err()
}
defer stmt.Close()
// Remove each IP address from the table. It's more efficient to update the slice of
// IP addresses once at the end rather than for each removal, so use a defer.
removed := make(map[int64]struct{}, len(t.removals))
defer func() {
var ips []*IP
for _, ip := range t.current {
if _, ok := removed[ip.Id]; !ok {
ips = append(ips, ip)
}
}
t.current = ips
}()
for len(t.removals) > 0 {
ip := t.removals[0]
if _, err := stmt.ExecContext(c, ip.Id); err != nil {
// Defer ensures the slice of IP addresses is updated even if we exit early.
return errors.Annotate(err, "failed to remove IP address %q", ip.IPv4).Err()
}
removed[ip.Id] = struct{}{}
t.removals = t.removals[1:]
logging.Infof(c, "Removed IP address %q", ip.IPv4)
}
return nil
} | go | func (t *IPsTable) remove(c context.Context) error {
// Avoid using the database connection to prepare unnecessary statements.
if len(t.removals) == 0 {
return nil
}
db := database.Get(c)
stmt, err := db.PrepareContext(c, `
DELETE FROM ips
WHERE id = ?
`)
if err != nil {
return errors.Annotate(err, "failed to prepare statement").Err()
}
defer stmt.Close()
// Remove each IP address from the table. It's more efficient to update the slice of
// IP addresses once at the end rather than for each removal, so use a defer.
removed := make(map[int64]struct{}, len(t.removals))
defer func() {
var ips []*IP
for _, ip := range t.current {
if _, ok := removed[ip.Id]; !ok {
ips = append(ips, ip)
}
}
t.current = ips
}()
for len(t.removals) > 0 {
ip := t.removals[0]
if _, err := stmt.ExecContext(c, ip.Id); err != nil {
// Defer ensures the slice of IP addresses is updated even if we exit early.
return errors.Annotate(err, "failed to remove IP address %q", ip.IPv4).Err()
}
removed[ip.Id] = struct{}{}
t.removals = t.removals[1:]
logging.Infof(c, "Removed IP address %q", ip.IPv4)
}
return nil
} | [
"func",
"(",
"t",
"*",
"IPsTable",
")",
"remove",
"(",
"c",
"context",
".",
"Context",
")",
"error",
"{",
"// Avoid using the database connection to prepare unnecessary statements.",
"if",
"len",
"(",
"t",
".",
"removals",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"db",
":=",
"database",
".",
"Get",
"(",
"c",
")",
"\n",
"stmt",
",",
"err",
":=",
"db",
".",
"PrepareContext",
"(",
"c",
",",
"`\n\t\tDELETE FROM ips\n\t\tWHERE id = ?\n\t`",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"defer",
"stmt",
".",
"Close",
"(",
")",
"\n\n",
"// Remove each IP address from the table. It's more efficient to update the slice of",
"// IP addresses once at the end rather than for each removal, so use a defer.",
"removed",
":=",
"make",
"(",
"map",
"[",
"int64",
"]",
"struct",
"{",
"}",
",",
"len",
"(",
"t",
".",
"removals",
")",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"var",
"ips",
"[",
"]",
"*",
"IP",
"\n",
"for",
"_",
",",
"ip",
":=",
"range",
"t",
".",
"current",
"{",
"if",
"_",
",",
"ok",
":=",
"removed",
"[",
"ip",
".",
"Id",
"]",
";",
"!",
"ok",
"{",
"ips",
"=",
"append",
"(",
"ips",
",",
"ip",
")",
"\n",
"}",
"\n",
"}",
"\n",
"t",
".",
"current",
"=",
"ips",
"\n",
"}",
"(",
")",
"\n",
"for",
"len",
"(",
"t",
".",
"removals",
")",
">",
"0",
"{",
"ip",
":=",
"t",
".",
"removals",
"[",
"0",
"]",
"\n",
"if",
"_",
",",
"err",
":=",
"stmt",
".",
"ExecContext",
"(",
"c",
",",
"ip",
".",
"Id",
")",
";",
"err",
"!=",
"nil",
"{",
"// Defer ensures the slice of IP addresses is updated even if we exit early.",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
",",
"ip",
".",
"IPv4",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"removed",
"[",
"ip",
".",
"Id",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"t",
".",
"removals",
"=",
"t",
".",
"removals",
"[",
"1",
":",
"]",
"\n",
"logging",
".",
"Infof",
"(",
"c",
",",
"\"",
"\"",
",",
"ip",
".",
"IPv4",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // remove removes all IP addresses pending removal from the database, clearing pending removals.
// No-op unless computeChanges was called first. Idempotent until computeChanges is called again. | [
"remove",
"removes",
"all",
"IP",
"addresses",
"pending",
"removal",
"from",
"the",
"database",
"clearing",
"pending",
"removals",
".",
"No",
"-",
"op",
"unless",
"computeChanges",
"was",
"called",
"first",
".",
"Idempotent",
"until",
"computeChanges",
"is",
"called",
"again",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/machine-db/appengine/model/ips.go#L165-L204 |
8,789 | luci/luci-go | machine-db/appengine/model/ips.go | update | func (t *IPsTable) update(c context.Context) error {
// Avoid using the database connection to prepare unnecessary statements.
if len(t.updates) == 0 {
return nil
}
db := database.Get(c)
stmt, err := db.PrepareContext(c, `
UPDATE ips
SET vlan_id = ?
WHERE id = ?
`)
if err != nil {
return errors.Annotate(err, "failed to prepare statement").Err()
}
defer stmt.Close()
// Update each IP address in the table. It's more efficient to update the slice of
// IP addresses once at the end rather than for each update, so use a defer.
updated := make(map[int64]*IP, len(t.updates))
defer func() {
for _, ip := range t.current {
if u, ok := updated[ip.Id]; ok {
ip.VLANId = u.VLANId
}
}
}()
for len(t.updates) > 0 {
ip := t.updates[0]
if _, err := stmt.ExecContext(c, ip.VLANId, ip.Id); err != nil {
return errors.Annotate(err, "failed to update IP address %q", ip.IPv4).Err()
}
updated[ip.Id] = ip
t.updates = t.updates[1:]
logging.Infof(c, "Updated IP address %q", ip.IPv4)
}
return nil
} | go | func (t *IPsTable) update(c context.Context) error {
// Avoid using the database connection to prepare unnecessary statements.
if len(t.updates) == 0 {
return nil
}
db := database.Get(c)
stmt, err := db.PrepareContext(c, `
UPDATE ips
SET vlan_id = ?
WHERE id = ?
`)
if err != nil {
return errors.Annotate(err, "failed to prepare statement").Err()
}
defer stmt.Close()
// Update each IP address in the table. It's more efficient to update the slice of
// IP addresses once at the end rather than for each update, so use a defer.
updated := make(map[int64]*IP, len(t.updates))
defer func() {
for _, ip := range t.current {
if u, ok := updated[ip.Id]; ok {
ip.VLANId = u.VLANId
}
}
}()
for len(t.updates) > 0 {
ip := t.updates[0]
if _, err := stmt.ExecContext(c, ip.VLANId, ip.Id); err != nil {
return errors.Annotate(err, "failed to update IP address %q", ip.IPv4).Err()
}
updated[ip.Id] = ip
t.updates = t.updates[1:]
logging.Infof(c, "Updated IP address %q", ip.IPv4)
}
return nil
} | [
"func",
"(",
"t",
"*",
"IPsTable",
")",
"update",
"(",
"c",
"context",
".",
"Context",
")",
"error",
"{",
"// Avoid using the database connection to prepare unnecessary statements.",
"if",
"len",
"(",
"t",
".",
"updates",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"db",
":=",
"database",
".",
"Get",
"(",
"c",
")",
"\n",
"stmt",
",",
"err",
":=",
"db",
".",
"PrepareContext",
"(",
"c",
",",
"`\n\t\tUPDATE ips\n\t\tSET vlan_id = ?\n\t\tWHERE id = ?\n\t`",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"defer",
"stmt",
".",
"Close",
"(",
")",
"\n\n",
"// Update each IP address in the table. It's more efficient to update the slice of",
"// IP addresses once at the end rather than for each update, so use a defer.",
"updated",
":=",
"make",
"(",
"map",
"[",
"int64",
"]",
"*",
"IP",
",",
"len",
"(",
"t",
".",
"updates",
")",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"for",
"_",
",",
"ip",
":=",
"range",
"t",
".",
"current",
"{",
"if",
"u",
",",
"ok",
":=",
"updated",
"[",
"ip",
".",
"Id",
"]",
";",
"ok",
"{",
"ip",
".",
"VLANId",
"=",
"u",
".",
"VLANId",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"for",
"len",
"(",
"t",
".",
"updates",
")",
">",
"0",
"{",
"ip",
":=",
"t",
".",
"updates",
"[",
"0",
"]",
"\n",
"if",
"_",
",",
"err",
":=",
"stmt",
".",
"ExecContext",
"(",
"c",
",",
"ip",
".",
"VLANId",
",",
"ip",
".",
"Id",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
",",
"ip",
".",
"IPv4",
")",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"updated",
"[",
"ip",
".",
"Id",
"]",
"=",
"ip",
"\n",
"t",
".",
"updates",
"=",
"t",
".",
"updates",
"[",
"1",
":",
"]",
"\n",
"logging",
".",
"Infof",
"(",
"c",
",",
"\"",
"\"",
",",
"ip",
".",
"IPv4",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // update updates all IP addresses pending update in the database, clearing pending updates.
// No-op unless computeChanges was called first. Idempotent until computeChanges is called again. | [
"update",
"updates",
"all",
"IP",
"addresses",
"pending",
"update",
"in",
"the",
"database",
"clearing",
"pending",
"updates",
".",
"No",
"-",
"op",
"unless",
"computeChanges",
"was",
"called",
"first",
".",
"Idempotent",
"until",
"computeChanges",
"is",
"called",
"again",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/machine-db/appengine/model/ips.go#L208-L245 |
8,790 | luci/luci-go | machine-db/appengine/model/ips.go | ids | func (t *IPsTable) ids(c context.Context) map[common.IPv4]int64 {
ips := make(map[common.IPv4]int64, len(t.current))
for _, ip := range t.current {
ips[ip.IPv4] = ip.Id
}
return ips
} | go | func (t *IPsTable) ids(c context.Context) map[common.IPv4]int64 {
ips := make(map[common.IPv4]int64, len(t.current))
for _, ip := range t.current {
ips[ip.IPv4] = ip.Id
}
return ips
} | [
"func",
"(",
"t",
"*",
"IPsTable",
")",
"ids",
"(",
"c",
"context",
".",
"Context",
")",
"map",
"[",
"common",
".",
"IPv4",
"]",
"int64",
"{",
"ips",
":=",
"make",
"(",
"map",
"[",
"common",
".",
"IPv4",
"]",
"int64",
",",
"len",
"(",
"t",
".",
"current",
")",
")",
"\n",
"for",
"_",
",",
"ip",
":=",
"range",
"t",
".",
"current",
"{",
"ips",
"[",
"ip",
".",
"IPv4",
"]",
"=",
"ip",
".",
"Id",
"\n",
"}",
"\n",
"return",
"ips",
"\n",
"}"
] | // ids returns a map of IP addresses to IDs. | [
"ids",
"returns",
"a",
"map",
"of",
"IP",
"addresses",
"to",
"IDs",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/machine-db/appengine/model/ips.go#L248-L254 |
8,791 | luci/luci-go | starlark/starlarkproto/conversions.go | checkAssignable | func checkAssignable(typ reflect.Type, val starlark.Value) error {
_, err := getAssigner(typ, val)
return err
} | go | func checkAssignable(typ reflect.Type, val starlark.Value) error {
_, err := getAssigner(typ, val)
return err
} | [
"func",
"checkAssignable",
"(",
"typ",
"reflect",
".",
"Type",
",",
"val",
"starlark",
".",
"Value",
")",
"error",
"{",
"_",
",",
"err",
":=",
"getAssigner",
"(",
"typ",
",",
"val",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // checkAssignable returns no errors if the given starlark value can be assigned
// to a go value of the given type. | [
"checkAssignable",
"returns",
"no",
"errors",
"if",
"the",
"given",
"starlark",
"value",
"can",
"be",
"assigned",
"to",
"a",
"go",
"value",
"of",
"the",
"given",
"type",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/starlark/starlarkproto/conversions.go#L190-L193 |
8,792 | luci/luci-go | starlark/starlarkproto/conversions.go | assign | func assign(gv reflect.Value, sv starlark.Value) error {
assigner, err := getAssigner(gv.Type(), sv)
if err != nil {
return err
}
return assigner(gv)
} | go | func assign(gv reflect.Value, sv starlark.Value) error {
assigner, err := getAssigner(gv.Type(), sv)
if err != nil {
return err
}
return assigner(gv)
} | [
"func",
"assign",
"(",
"gv",
"reflect",
".",
"Value",
",",
"sv",
"starlark",
".",
"Value",
")",
"error",
"{",
"assigner",
",",
"err",
":=",
"getAssigner",
"(",
"gv",
".",
"Type",
"(",
")",
",",
"sv",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"assigner",
"(",
"gv",
")",
"\n",
"}"
] | // assign assigns the given starlark value to the given go value, if types
// allow. | [
"assign",
"assigns",
"the",
"given",
"starlark",
"value",
"to",
"the",
"given",
"go",
"value",
"if",
"types",
"allow",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/starlark/starlarkproto/conversions.go#L197-L203 |
8,793 | luci/luci-go | starlark/starlarkproto/conversions.go | refuseProto2 | func refuseProto2(typ reflect.Type) error {
if typ.Kind() == reflect.Ptr && typ.Elem().Kind() != reflect.Struct {
return errNoProto2
}
return nil
} | go | func refuseProto2(typ reflect.Type) error {
if typ.Kind() == reflect.Ptr && typ.Elem().Kind() != reflect.Struct {
return errNoProto2
}
return nil
} | [
"func",
"refuseProto2",
"(",
"typ",
"reflect",
".",
"Type",
")",
"error",
"{",
"if",
"typ",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"&&",
"typ",
".",
"Elem",
"(",
")",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Struct",
"{",
"return",
"errNoProto2",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // refuseProto2 returns errNoProto2 if the given typ came from proto2 message.
//
// Proto3 use pointers only to represent message-valued fields. Proto2 also
// uses them to represent scalar-valued fields. We don't support proto2. So
// check that if typ is a pointer, it points to a struct. | [
"refuseProto2",
"returns",
"errNoProto2",
"if",
"the",
"given",
"typ",
"came",
"from",
"proto2",
"message",
".",
"Proto3",
"use",
"pointers",
"only",
"to",
"represent",
"message",
"-",
"valued",
"fields",
".",
"Proto2",
"also",
"uses",
"them",
"to",
"represent",
"scalar",
"-",
"valued",
"fields",
".",
"We",
"don",
"t",
"support",
"proto2",
".",
"So",
"check",
"that",
"if",
"typ",
"is",
"a",
"pointer",
"it",
"points",
"to",
"a",
"struct",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/starlark/starlarkproto/conversions.go#L316-L321 |
8,794 | luci/luci-go | starlark/starlarkproto/conversions.go | typDesc | func typDesc(typ reflect.Type) string {
if typ.Kind() == reflect.Ptr {
if msgT, err := GetMessageType(typ); err == nil {
return fmt.Sprintf("a %s message", msgT.Name())
}
}
return fmt.Sprintf("a value of kind %q", typ.Kind())
} | go | func typDesc(typ reflect.Type) string {
if typ.Kind() == reflect.Ptr {
if msgT, err := GetMessageType(typ); err == nil {
return fmt.Sprintf("a %s message", msgT.Name())
}
}
return fmt.Sprintf("a value of kind %q", typ.Kind())
} | [
"func",
"typDesc",
"(",
"typ",
"reflect",
".",
"Type",
")",
"string",
"{",
"if",
"typ",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"if",
"msgT",
",",
"err",
":=",
"GetMessageType",
"(",
"typ",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"msgT",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"typ",
".",
"Kind",
"(",
")",
")",
"\n",
"}"
] | // typDesc returns a human readable description of the type, for error messages.
//
// Recognize proto types and report their proto names. Otherwise just reports
// typ's kind. | [
"typDesc",
"returns",
"a",
"human",
"readable",
"description",
"of",
"the",
"type",
"for",
"error",
"messages",
".",
"Recognize",
"proto",
"types",
"and",
"report",
"their",
"proto",
"names",
".",
"Otherwise",
"just",
"reports",
"typ",
"s",
"kind",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/starlark/starlarkproto/conversions.go#L327-L334 |
8,795 | luci/luci-go | common/clock/external.go | SetFactory | func SetFactory(ctx context.Context, f Factory) context.Context {
return context.WithValue(ctx, &clockKey, f)
} | go | func SetFactory(ctx context.Context, f Factory) context.Context {
return context.WithValue(ctx, &clockKey, f)
} | [
"func",
"SetFactory",
"(",
"ctx",
"context",
".",
"Context",
",",
"f",
"Factory",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"&",
"clockKey",
",",
"f",
")",
"\n",
"}"
] | // SetFactory creates a new Context using the supplied Clock factory. | [
"SetFactory",
"creates",
"a",
"new",
"Context",
"using",
"the",
"supplied",
"Clock",
"factory",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/clock/external.go#L29-L31 |
8,796 | luci/luci-go | common/clock/external.go | Set | func Set(ctx context.Context, c Clock) context.Context {
return SetFactory(ctx, func(context.Context) Clock { return c })
} | go | func Set(ctx context.Context, c Clock) context.Context {
return SetFactory(ctx, func(context.Context) Clock { return c })
} | [
"func",
"Set",
"(",
"ctx",
"context",
".",
"Context",
",",
"c",
"Clock",
")",
"context",
".",
"Context",
"{",
"return",
"SetFactory",
"(",
"ctx",
",",
"func",
"(",
"context",
".",
"Context",
")",
"Clock",
"{",
"return",
"c",
"}",
")",
"\n",
"}"
] | // Set creates a new Context using the supplied Clock. | [
"Set",
"creates",
"a",
"new",
"Context",
"using",
"the",
"supplied",
"Clock",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/clock/external.go#L34-L36 |
8,797 | luci/luci-go | common/clock/external.go | Sleep | func Sleep(ctx context.Context, d time.Duration) TimerResult {
return Get(ctx).Sleep(ctx, d)
} | go | func Sleep(ctx context.Context, d time.Duration) TimerResult {
return Get(ctx).Sleep(ctx, d)
} | [
"func",
"Sleep",
"(",
"ctx",
"context",
".",
"Context",
",",
"d",
"time",
".",
"Duration",
")",
"TimerResult",
"{",
"return",
"Get",
"(",
"ctx",
")",
".",
"Sleep",
"(",
"ctx",
",",
"d",
")",
"\n",
"}"
] | // Sleep calls Clock.Sleep on the Clock instance stored in the supplied Context. | [
"Sleep",
"calls",
"Clock",
".",
"Sleep",
"on",
"the",
"Clock",
"instance",
"stored",
"in",
"the",
"supplied",
"Context",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/clock/external.go#L58-L60 |
8,798 | luci/luci-go | common/clock/external.go | Since | func Since(ctx context.Context, t time.Time) time.Duration {
return Now(ctx).Sub(t)
} | go | func Since(ctx context.Context, t time.Time) time.Duration {
return Now(ctx).Sub(t)
} | [
"func",
"Since",
"(",
"ctx",
"context",
".",
"Context",
",",
"t",
"time",
".",
"Time",
")",
"time",
".",
"Duration",
"{",
"return",
"Now",
"(",
"ctx",
")",
".",
"Sub",
"(",
"t",
")",
"\n",
"}"
] | // Since is an equivalent of time.Since. | [
"Since",
"is",
"an",
"equivalent",
"of",
"time",
".",
"Since",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/common/clock/external.go#L74-L76 |
8,799 | luci/luci-go | tools/cmd/assets/main.go | run | func run(dir string, extraExts []string) error {
exts := defaultExts.Union(stringset.NewFromSlice(extraExts...)).ToSlice()
sort.Strings(exts)
pkg, err := build.ImportDir(dir, build.ImportComment)
if err != nil {
return fmt.Errorf("can't import dir %q - %s", dir, err)
}
assets, err := findAssets(pkg.Dir, exts)
if err != nil {
return fmt.Errorf("can't find assets in %s - %s", pkg.Dir, err)
}
err = generate(assetsGenGoTmpl, pkg, assets, exts, filepath.Join(pkg.Dir, "assets.gen.go"))
if err != nil {
return fmt.Errorf("can't generate assets.gen.go - %s", err)
}
err = generate(assetsTestTmpl, pkg, assets, exts, filepath.Join(pkg.Dir, "assets_test.go"))
if err != nil {
return fmt.Errorf("can't generate assets_test.go - %s", err)
}
return nil
} | go | func run(dir string, extraExts []string) error {
exts := defaultExts.Union(stringset.NewFromSlice(extraExts...)).ToSlice()
sort.Strings(exts)
pkg, err := build.ImportDir(dir, build.ImportComment)
if err != nil {
return fmt.Errorf("can't import dir %q - %s", dir, err)
}
assets, err := findAssets(pkg.Dir, exts)
if err != nil {
return fmt.Errorf("can't find assets in %s - %s", pkg.Dir, err)
}
err = generate(assetsGenGoTmpl, pkg, assets, exts, filepath.Join(pkg.Dir, "assets.gen.go"))
if err != nil {
return fmt.Errorf("can't generate assets.gen.go - %s", err)
}
err = generate(assetsTestTmpl, pkg, assets, exts, filepath.Join(pkg.Dir, "assets_test.go"))
if err != nil {
return fmt.Errorf("can't generate assets_test.go - %s", err)
}
return nil
} | [
"func",
"run",
"(",
"dir",
"string",
",",
"extraExts",
"[",
"]",
"string",
")",
"error",
"{",
"exts",
":=",
"defaultExts",
".",
"Union",
"(",
"stringset",
".",
"NewFromSlice",
"(",
"extraExts",
"...",
")",
")",
".",
"ToSlice",
"(",
")",
"\n",
"sort",
".",
"Strings",
"(",
"exts",
")",
"\n\n",
"pkg",
",",
"err",
":=",
"build",
".",
"ImportDir",
"(",
"dir",
",",
"build",
".",
"ImportComment",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"dir",
",",
"err",
")",
"\n",
"}",
"\n\n",
"assets",
",",
"err",
":=",
"findAssets",
"(",
"pkg",
".",
"Dir",
",",
"exts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"pkg",
".",
"Dir",
",",
"err",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"generate",
"(",
"assetsGenGoTmpl",
",",
"pkg",
",",
"assets",
",",
"exts",
",",
"filepath",
".",
"Join",
"(",
"pkg",
".",
"Dir",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"generate",
"(",
"assetsTestTmpl",
",",
"pkg",
",",
"assets",
",",
"exts",
",",
"filepath",
".",
"Join",
"(",
"pkg",
".",
"Dir",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // run generates assets.gen.go file with all assets discovered in the directory. | [
"run",
"generates",
"assets",
".",
"gen",
".",
"go",
"file",
"with",
"all",
"assets",
"discovered",
"in",
"the",
"directory",
"."
] | f6cef429871eee3be7c6903af88d3ee884eaf683 | https://github.com/luci/luci-go/blob/f6cef429871eee3be7c6903af88d3ee884eaf683/tools/cmd/assets/main.go#L228-L253 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.