Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "translateLevel", "(", "l", "logging", ".", "Level", ")", "int", "{", "switch", "l", "{", "case", "Suppress", ":", "return", "-", "1", "\n", "case", "logging", ".", "Error", ":", "return", "0", "\n", "case", "logging", ".", "Warning", ",", "logging", ".", "Info", ":", "return", "1", "\n", "default", ":", "return", "2", "\n", "}", "\n", "}" ]

[ "translateLevel", "translates", "a", "verbose", "level", "to", "a", "logging", "level", "." ]

[ "func", "InstallHandlers", "(", "r", "*", "router", ".", "Router", ",", "base", "router", ".", "MiddlewareChain", ")", "{", "m", ":=", "CookieAuth", ".", "(", "cookieAuthMethod", ")", "\n", "if", "oid", ",", "ok", ":=", "m", ".", "Method", ".", "(", "*", "openid", ".", "AuthMethod", ")", ";", "ok", "{", "oid", ".", "InstallHandlers", "(", "r", ",", "base", ")", "\n", "}", "\n", "auth", ".", "InstallHandlers", "(", "r", ",", "base", ")", "\n", "authdbimpl", ".", "InstallHandlers", "(", "r", ",", "base", ")", "\n", "}" ]

[ "InstallHandlers", "installs", "HTTP", "handlers", "for", "various", "default", "routes", "related", "to", "authentication", "system", ".", "Must", "be", "installed", "in", "server", "HTTP", "router", "for", "authentication", "to", "work", "." ]

[ "func", "(", "c", "*", "CipdPackage", ")", "ToCipdPackage", "(", ")", "*", "swarm", ".", "SwarmingRpcsCipdPackage", "{", "if", "c", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "&", "swarm", ".", "SwarmingRpcsCipdPackage", "{", "PackageName", ":", "c", ".", "Name", ",", "Version", ":", "c", ".", "Version", "}", "\n", "}" ]

[ "ToCipdPackage", "converts", "this", "to", "a", "swarming", "api", "SwarmingRpcsCipdPackage", "." ]

[ "func", "(", "c", "*", "CipdSpec", ")", "ToCipdInput", "(", ")", "*", "swarm", ".", "SwarmingRpcsCipdInput", "{", "if", "c", "==", "nil", "||", "c", ".", "Client", "==", "nil", "&&", "len", "(", "c", ".", "ByPath", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "ret", ":=", "&", "swarm", ".", "SwarmingRpcsCipdInput", "{", "ClientPackage", ":", "c", ".", "Client", ".", "ToCipdPackage", "(", ")", ",", "}", "\n", "if", "len", "(", "c", ".", "ByPath", ")", ">", "0", "{", "count", ":=", "0", "\n", "paths", ":=", "make", "(", "sort", ".", "StringSlice", ",", "0", ",", "len", "(", "c", ".", "ByPath", ")", ")", "\n", "for", "path", ",", "pkgs", ":=", "range", "c", ".", "ByPath", "{", "paths", "=", "append", "(", "paths", ",", "path", ")", "\n", "count", "+=", "len", "(", "pkgs", ".", "Pkg", ")", "\n", "}", "\n", "ret", ".", "Packages", "=", "make", "(", "[", "]", "*", "swarm", ".", "SwarmingRpcsCipdPackage", ",", "0", ",", "count", ")", "\n", "for", "_", ",", "path", ":=", "range", "paths", "{", "for", "_", ",", "pkg", ":=", "range", "c", ".", "ByPath", "[", "path", "]", ".", "Pkg", "{", "retPkg", ":=", "pkg", ".", "ToCipdPackage", "(", ")", "\n", "retPkg", ".", "Path", "=", "path", "\n", "ret", ".", "Packages", "=", "append", "(", "ret", ".", "Packages", ",", "retPkg", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "ToCipdInput", "converts", "this", "to", "a", "swarming", "api", "SwarmingRpcsCipdInput", "." ]

[ "func", "MakeIdentity", "(", "identity", "string", ")", "(", "Identity", ",", "error", ")", "{", "id", ":=", "Identity", "(", "identity", ")", "\n", "if", "err", ":=", "id", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "id", ",", "nil", "\n", "}" ]

[ "MakeIdentity", "ensures", "identity", "string", "looks", "like", "a", "valid", "identity", "and", "returns", "it", "as", "Identity", "value", "." ]

[ "func", "(", "id", "Identity", ")", "Validate", "(", ")", "error", "{", "chunks", ":=", "strings", ".", "SplitN", "(", "string", "(", "id", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "re", ":=", "knownKinds", "[", "Kind", "(", "chunks", "[", "0", "]", ")", "]", "\n", "if", "re", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "chunks", "[", "0", "]", ")", "\n", "}", "\n", "if", "!", "re", ".", "MatchString", "(", "chunks", "[", "1", "]", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "chunks", "[", "1", "]", ",", "chunks", "[", "0", "]", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "checks", "that", "the", "identity", "string", "is", "well", "-", "formed", "." ]

[ "func", "(", "id", "Identity", ")", "Kind", "(", ")", "Kind", "{", "chunks", ":=", "strings", ".", "SplitN", "(", "string", "(", "id", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "return", "Anonymous", "\n", "}", "\n", "return", "Kind", "(", "chunks", "[", "0", "]", ")", "\n", "}" ]

[ "Kind", "returns", "identity", "kind", ".", "If", "identity", "string", "is", "invalid", "returns", "Anonymous", "." ]

[ "func", "(", "id", "Identity", ")", "Email", "(", ")", "string", "{", "chunks", ":=", "strings", ".", "SplitN", "(", "string", "(", "id", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "chunks", ")", "!=", "2", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "Kind", "(", "chunks", "[", "0", "]", ")", "==", "User", "{", "return", "chunks", "[", "1", "]", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "Email", "returns", "user", "s", "email", "for", "identity", "with", "kind", "User", "or", "empty", "string", "for", "all", "other", "identity", "kinds", ".", "If", "identity", "string", "is", "undefined", "returns", "." ]

[ "func", "TagValueIn", "(", "t", "TagKey", ",", "err", "error", ")", "(", "value", "interface", "{", "}", ",", "ok", "bool", ")", "{", "Walk", "(", "err", ",", "func", "(", "err", "error", ")", "bool", "{", "if", "sc", ",", "isSC", ":=", "err", ".", "(", "stackContexter", ")", ";", "isSC", "{", "if", "value", ",", "ok", "=", "sc", ".", "stackContext", "(", ")", ".", "tags", "[", "t", "]", ";", "ok", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "return", "\n", "}" ]

[ "TagValueIn", "will", "retrieve", "the", "tagged", "value", "from", "the", "error", "that", "s", "associated", "with", "this", "key", "and", "a", "boolean", "indicating", "if", "the", "tag", "was", "present", "or", "not", "." ]

[ "func", "(", "b", "BoolTag", ")", "In", "(", "err", "error", ")", "bool", "{", "v", ",", "ok", ":=", "TagValueIn", "(", "b", ".", "Key", ",", "err", ")", "\n", "if", "!", "ok", "{", "return", "false", "\n", "}", "\n", "return", "v", ".", "(", "bool", ")", "\n", "}" ]

[ "In", "returns", "true", "iff", "this", "tag", "value", "has", "been", "set", "to", "true", "on", "this", "error", "." ]

[ "func", "GetTags", "(", "err", "error", ")", "map", "[", "TagKey", "]", "interface", "{", "}", "{", "ret", ":=", "map", "[", "TagKey", "]", "interface", "{", "}", "{", "}", "\n", "Walk", "(", "err", ",", "func", "(", "err", "error", ")", "bool", "{", "if", "sc", ",", "ok", ":=", "err", ".", "(", "stackContexter", ")", ";", "ok", "{", "ctx", ":=", "sc", ".", "stackContext", "(", ")", "\n", "for", "k", ",", "v", ":=", "range", "ctx", ".", "tags", "{", "if", "_", ",", "ok", ":=", "ret", "[", "k", "]", ";", "!", "ok", "{", "ret", "[", "k", "]", "=", "v", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "return", "ret", "\n", "}" ]

[ "GetTags", "returns", "a", "map", "of", "all", "TagKeys", "set", "in", "this", "error", "to", "their", "value", ".", "A", "nil", "value", "means", "that", "the", "tag", "is", "present", "but", "has", "a", "nil", "associated", "value", ".", "This", "is", "done", "in", "a", "depth", "-", "first", "traversal", "of", "the", "error", "stack", "with", "the", "most", "-", "recently", "-", "set", "value", "of", "the", "tag", "taking", "precendence", "." ]

[ "func", "schemaFromMessage", "(", "desc", "*", "descriptor", ".", "FileDescriptorSet", ",", "messageName", "string", ")", "(", "schema", "bigquery", ".", "Schema", ",", "description", "string", ",", "err", "error", ")", "{", "conv", ":=", "schemaConverter", "{", "desc", ":", "desc", ",", "sourceCodeInfo", ":", "make", "(", "map", "[", "*", "descriptor", ".", "FileDescriptorProto", "]", "sourceCodeInfoMap", ",", "len", "(", "desc", ".", "File", ")", ")", ",", "}", "\n", "for", "_", ",", "f", ":=", "range", "desc", ".", "File", "{", "conv", ".", "sourceCodeInfo", "[", "f", "]", ",", "err", "=", "descutil", ".", "IndexSourceCodeInfo", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "f", ".", "GetName", "(", ")", ")", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n", "return", "conv", ".", "schema", "(", "messageName", ")", "\n", "}" ]

[ "schemaFromMessage", "loads", "a", "message", "by", "name", "from", ".", "proto", "files", "in", "dir", "and", "converts", "the", "message", "to", "a", "bigquery", "schema", "." ]

[ "func", "loadProtoDescription", "(", "dir", "string", ",", "importPaths", "[", "]", "string", ")", "(", "*", "descriptor", ".", "FileDescriptorSet", ",", "error", ")", "{", "dir", ",", "err", ":=", "filepath", ".", "Abs", "(", "dir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "dir", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "tempDir", ",", "err", ":=", "ioutil", ".", "TempDir", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "os", ".", "RemoveAll", "(", "tempDir", ")", "\n", "descFile", ":=", "filepath", ".", "Join", "(", "tempDir", ",", "\"", "\"", ")", "\n\n", "importPaths", ",", "err", "=", "protoImportPaths", "(", "dir", ",", "importPaths", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "args", ":=", "[", "]", "string", "{", "\"", "\"", "+", "descFile", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "for", "_", ",", "p", ":=", "range", "importPaths", "{", "args", "=", "append", "(", "args", ",", "\"", "\"", "+", "p", ")", "\n", "}", "\n", "protoFiles", ",", "err", ":=", "filepath", ".", "Glob", "(", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "protoFiles", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dir", ")", "\n", "}", "\n", "args", "=", "append", "(", "args", ",", "protoFiles", "...", ")", "\n\n", "protoc", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "args", "...", ")", "\n", "protoc", ".", "Stderr", "=", "os", ".", "Stderr", "\n", "if", "err", ":=", "protoc", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "descBytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "descFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "desc", "descriptor", ".", "FileDescriptorSet", "\n", "err", "=", "proto", ".", "Unmarshal", "(", "descBytes", ",", "&", "desc", ")", "\n", "return", "&", "desc", ",", "err", "\n", "}" ]

[ "loadProtoDescription", "compiles", ".", "proto", "files", "in", "the", "dir", "and", "returns", "their", "descriptor", "." ]

[ "func", "confirm", "(", "action", "string", ")", "(", "response", "bool", ")", "{", "fmt", ".", "Printf", "(", "\"", "\"", ",", "action", ")", "\n", "var", "res", "string", "\n", "fmt", ".", "Scanln", "(", "&", "res", ")", "\n", "return", "res", "==", "\"", "\"", "||", "res", "==", "\"", "\"", "\n", "}" ]

[ "confirm", "asks", "for", "a", "user", "confirmation", "for", "an", "action", "with", "No", "as", "default", ".", "Only", "y", "or", "Y", "responses", "is", "treated", "as", "yes", "." ]

[ "func", "(", "e", "*", "Ref", ")", "Proto", "(", ")", "*", "api", ".", "Ref", "{", "return", "&", "api", ".", "Ref", "{", "Name", ":", "e", ".", "Name", ",", "Package", ":", "e", ".", "Package", ".", "StringID", "(", ")", ",", "Instance", ":", "common", ".", "InstanceIDToObjectRef", "(", "e", ".", "InstanceID", ")", ",", "ModifiedBy", ":", "e", ".", "ModifiedBy", ",", "ModifiedTs", ":", "google", ".", "NewTimestamp", "(", "e", ".", "ModifiedTs", ")", ",", "}", "\n", "}" ]

[ "Proto", "returns", "cipd", ".", "Ref", "proto", "with", "information", "from", "this", "entity", "." ]

[ "func", "GetRef", "(", "c", "context", ".", "Context", ",", "pkg", ",", "ref", "string", ")", "(", "*", "Ref", ",", "error", ")", "{", "r", ":=", "&", "Ref", "{", "Name", ":", "ref", ",", "Package", ":", "PackageKey", "(", "c", ",", "pkg", ")", "}", "\n", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "r", ")", ";", "{", "case", "err", "==", "datastore", ".", "ErrNoSuchEntity", ":", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Tag", "(", "grpcutil", ".", "NotFoundTag", ")", ".", "Err", "(", ")", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "r", ",", "nil", "\n", "}" ]

[ "GetRef", "fetches", "the", "given", "ref", ".", "Returns", "gRPC", "-", "tagged", "NotFound", "error", "if", "there", "s", "no", "such", "ref", "." ]

[ "func", "DeleteRef", "(", "c", "context", ".", "Context", ",", "pkg", ",", "ref", "string", ")", "error", "{", "return", "Txn", "(", "c", ",", "\"", "\"", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "r", ",", "err", ":=", "GetRef", "(", "c", ",", "pkg", ",", "ref", ")", "\n", "switch", "{", "case", "grpcutil", ".", "Code", "(", "err", ")", "==", "codes", ".", "NotFound", ":", "return", "nil", "\n", "case", "err", "!=", "nil", ":", "return", "err", "// transient", "\n", "}", "\n\n", "err", "=", "datastore", ".", "Delete", "(", "c", ",", "&", "Ref", "{", "Name", ":", "ref", ",", "Package", ":", "PackageKey", "(", "c", ",", "pkg", ")", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n\n", "return", "EmitEvent", "(", "c", ",", "&", "api", ".", "Event", "{", "Kind", ":", "api", ".", "EventKind_INSTANCE_REF_UNSET", ",", "Package", ":", "pkg", ",", "Instance", ":", "r", ".", "InstanceID", ",", "Ref", ":", "ref", ",", "}", ")", "\n", "}", ")", "\n", "}" ]

[ "DeleteRef", "removes", "the", "ref", "if", "it", "exists", ".", "Does", "nothing", "if", "there", "s", "no", "such", "ref", "or", "package", "." ]

[ "func", "ListPackageRefs", "(", "c", "context", ".", "Context", ",", "pkg", "string", ")", "(", "out", "[", "]", "*", "Ref", ",", "err", "error", ")", "{", "q", ":=", "datastore", ".", "NewQuery", "(", "\"", "\"", ")", ".", "Ancestor", "(", "PackageKey", "(", "c", ",", "pkg", ")", ")", ".", "Order", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "datastore", ".", "GetAll", "(", "c", ",", "q", ",", "&", "out", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "ListPackageRefs", "returns", "all", "refs", "in", "a", "package", "most", "recently", "modified", "first", ".", "Returns", "an", "empty", "list", "if", "there", "s", "no", "such", "package", "at", "all", "." ]

[ "func", "ListInstanceRefs", "(", "c", "context", ".", "Context", ",", "inst", "*", "Instance", ")", "(", "out", "[", "]", "*", "Ref", ",", "err", "error", ")", "{", "if", "inst", ".", "Package", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "q", ":=", "datastore", ".", "NewQuery", "(", "\"", "\"", ")", ".", "Ancestor", "(", "inst", ".", "Package", ")", ".", "Eq", "(", "\"", "\"", ",", "inst", ".", "InstanceID", ")", ".", "Order", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "datastore", ".", "GetAll", "(", "c", ",", "q", ",", "&", "out", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "ListInstanceRefs", "returns", "all", "refs", "that", "point", "to", "a", "particular", "instance", "most", "recently", "modified", "first", ".", "This", "is", "a", "subset", "of", "the", "output", "of", "ListPackageRefs", "for", "the", "corresponding", "package", ".", "Assumes", "inst", "is", "a", "valid", "Instance", "panics", "otherwise", ".", "Returns", "an", "empty", "list", "if", "there", "s", "no", "such", "instance", "at", "all", "." ]

[ "func", "(", "op", "*", "triageOp", ")", "prepare", "(", "c", "context", ".", "Context", ")", "error", "{", "op", ".", "started", "=", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", "// used to derive relative time in the debug log", "\n", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ")", "\n\n", "op", ".", "finishedSet", "=", "recentlyFinishedSet", "(", "c", ",", "op", ".", "jobID", ")", "\n", "op", ".", "triggersSet", "=", "pendingTriggersSet", "(", "c", ",", "op", ".", "jobID", ")", "\n\n", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "wg", ".", "Add", "(", "2", ")", "\n\n", "// Grab all pending triggers to decided what to do with them.", "var", "triggersErr", "error", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "op", ".", "triggersList", ",", "op", ".", "readyTriggers", ",", "triggersErr", "=", "op", ".", "triggersSet", ".", "Triggers", "(", "c", ")", "\n", "if", "triggersErr", "!=", "nil", "{", "op", ".", "debugErrLog", "(", "c", ",", "triggersErr", ",", "\"", "\"", ")", "\n", "}", "else", "{", "sortTriggers", "(", "op", ".", "readyTriggers", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Grab a list of recently finished invocations to remove them from", "// ActiveInvocations list.", "var", "finishedErr", "error", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "op", ".", "finishedList", ",", "finishedErr", "=", "op", ".", "finishedSet", ".", "List", "(", "c", ")", "\n", "if", "finishedErr", "!=", "nil", "{", "op", ".", "debugErrLog", "(", "c", ",", "finishedErr", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "wg", ".", "Wait", "(", ")", "\n", "if", "triggersErr", "!=", "nil", "||", "finishedErr", "!=", "nil", "{", "return", "errTriagePrepareFail", "// the original error is already logged", "\n", "}", "\n\n", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ",", "len", "(", "op", ".", "triggersList", ".", "Items", ")", ",", "len", "(", "op", ".", "triggersList", ".", "Garbage", ")", ")", "\n", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ",", "len", "(", "op", ".", "finishedList", ".", "Items", ")", ",", "len", "(", "op", ".", "finishedList", ".", "Garbage", ")", ")", "\n\n", "// Remove old tombstones to keep the set tidy. We fail hard here on errors to", "// make sure progress stops if garbage can't be cleaned up for some reason.", "// It is better to fail early rather than silently accumulate tons of garbage", "// until everything grinds to a halt.", "if", "err", ":=", "dsset", ".", "CleanupGarbage", "(", "c", ",", "op", ".", "triggersList", ".", "Garbage", ",", "op", ".", "finishedList", ".", "Garbage", ")", ";", "err", "!=", "nil", "{", "op", ".", "debugErrLog", "(", "c", ",", "err", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n\n", "// Log something mostly to capture the timestamp.", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "prepare", "fetches", "all", "pending", "triggers", "and", "events", "from", "dsset", "structs", "." ]

[ "func", "(", "op", "*", "triageOp", ")", "debugErrLog", "(", "c", "context", ".", "Context", ",", "err", "error", ",", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "if", "err", "==", "nil", "{", "logging", ".", "Errorf", "(", "c", ",", "format", ",", "args", "...", ")", "\n", "op", ".", "appendToLog", "(", "c", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "format", ",", "args", "...", ")", ")", "\n", "}", "else", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "format", ",", "args", "...", ")", "\n", "op", ".", "appendToLog", "(", "c", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "format", "+", "\"", "\"", ",", "append", "(", "args", ",", "err", ")", "...", ")", ")", "\n", "}", "\n", "}" ]

[ "debugErrLog", "adds", "a", "line", "to", "the", "triage", "debug", "log", "and", "Errorf", "log", "." ]

[ "func", "(", "op", "*", "triageOp", ")", "appendToLog", "(", "c", "context", ".", "Context", ",", "msg", "string", ")", "{", "const", "maxMessageCount", "=", "1000", "\n\n", "ms", ":=", "clock", ".", "Now", "(", "c", ")", ".", "Sub", "(", "op", ".", "started", ")", ".", "Nanoseconds", "(", ")", "/", "1e6", "\n\n", "op", ".", "debugLogLock", ".", "Lock", "(", ")", "\n", "if", "op", ".", "debugLogMsgs", "<=", "maxMessageCount", "{", "if", "op", ".", "debugLogMsgs", "<", "maxMessageCount", "{", "fmt", ".", "Fprintf", "(", "&", "op", ".", "debugLog", ",", "\"", "\\n", "\"", ",", "ms", ",", "msg", ")", "\n", "}", "else", "{", "fmt", ".", "Fprintf", "(", "&", "op", ".", "debugLog", ",", "\"", "\"", ")", "\n", "}", "\n", "op", ".", "debugLogMsgs", "++", "\n", "}", "\n", "op", ".", "debugLogLock", ".", "Unlock", "(", ")", "\n", "}" ]

[ "appendToLog", "adds", "a", "line", "to", "the", "debug", "log", "prefixing", "it", "with", "current", "time", "." ]

[ "func", "(", "op", "*", "triageOp", ")", "tidyActiveInvocations", "(", "c", "context", ".", "Context", ",", "job", "*", "Job", ")", "(", "*", "dsset", ".", "PopOp", ",", "error", ")", "{", "now", ":=", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", "\n\n", "// Deserialize the list of recently finished invocations, as stored in the", "// entity. Discard old items right away. If it is broken, log, but proceed.", "// It is ~OK to loose it (this will temporary cause some API calls to return", "// incomplete data).", "finishedRecord", ",", "err", ":=", "filteredFinishedInvs", "(", "job", ".", "FinishedInvocationsRaw", ",", "now", ".", "Add", "(", "-", "FinishedInvocationsHorizon", ")", ")", "\n", "if", "err", "!=", "nil", "{", "op", ".", "debugErrLog", "(", "c", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Note that per dsset API we need to do BeginPop if there's some garbage,", "// even if Items is empty. We can skip this if both lists are empty though.", "var", "popOp", "*", "dsset", ".", "PopOp", "\n", "if", "len", "(", "op", ".", "finishedList", ".", "Items", ")", "!=", "0", "||", "len", "(", "op", ".", "finishedList", ".", "Garbage", ")", "!=", "0", "{", "popOp", ",", "err", "=", "op", ".", "finishedSet", ".", "BeginPop", "(", "c", ",", "op", ".", "finishedList", ")", "\n", "if", "err", "!=", "nil", "{", "op", ".", "debugErrLog", "(", "c", ",", "err", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Items can have IDs popped by some other transaction already. Collect", "// only ones consumed by us here.", "reallyFinished", ":=", "make", "(", "map", "[", "int64", "]", "struct", "{", "}", ",", "len", "(", "op", ".", "finishedList", ".", "Items", ")", ")", "\n", "for", "_", ",", "itm", ":=", "range", "op", ".", "finishedList", ".", "Items", "{", "if", "popOp", ".", "Pop", "(", "itm", ".", "ID", ")", "{", "reallyFinished", "[", "op", ".", "finishedSet", ".", "ItemToInvID", "(", "&", "itm", ")", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n\n", "// Remove IDs of all finished invocations from ActiveInvocations list,", "// preserving the order, and add them to the finished invocations list.", "if", "len", "(", "reallyFinished", ")", "!=", "0", "{", "filtered", ":=", "make", "(", "[", "]", "int64", ",", "0", ",", "len", "(", "job", ".", "ActiveInvocations", ")", ")", "\n", "for", "_", ",", "id", ":=", "range", "job", ".", "ActiveInvocations", "{", "if", "_", ",", "yep", ":=", "reallyFinished", "[", "id", "]", ";", "!", "yep", "{", "filtered", "=", "append", "(", "filtered", ",", "id", ")", "// still running", "\n", "continue", "\n", "}", "\n", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ",", "id", ")", "\n", "finishedRecord", "=", "append", "(", "finishedRecord", ",", "&", "internal", ".", "FinishedInvocation", "{", "InvocationId", ":", "id", ",", "Finished", ":", "google", ".", "NewTimestamp", "(", "now", ")", ",", "}", ")", "\n", "}", "\n", "job", ".", "ActiveInvocations", "=", "filtered", "\n", "}", "\n", "}", "\n\n", "// Marshal back FinishedInvocationsRaw after it has been updated.", "job", ".", "FinishedInvocationsRaw", "=", "marshalFinishedInvs", "(", "finishedRecord", ")", "\n\n", "// Log summary.", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ",", "len", "(", "job", ".", "ActiveInvocations", ")", ")", "\n", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ",", "len", "(", "finishedRecord", ")", ")", "\n\n", "return", "popOp", ",", "nil", "\n", "}" ]

[ "tidyActiveInvocations", "removes", "finished", "invocations", "from", "ActiveInvocations", "and", "adds", "them", "to", "FinishedInvocations", ".", "Called", "within", "a", "transaction", ".", "Mutates", "job", ".", "Returns", "an", "open", "dsset", ".", "PopOp", "that", "must", "be", "eventually", "submitted", "with", "dsset", ".", "FinishPop", "." ]

[ "func", "(", "op", "*", "triageOp", ")", "processTriggers", "(", "c", "context", ".", "Context", ",", "job", "*", "Job", ")", "(", "*", "dsset", ".", "PopOp", ",", "error", ")", "{", "popOp", ",", "err", ":=", "op", ".", "triggersSet", ".", "BeginPop", "(", "c", ",", "op", ".", "triggersList", ")", "\n", "if", "err", "!=", "nil", "{", "op", ".", "debugErrLog", "(", "c", ",", "err", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Filter out all triggers already popped by some other transaction.", "triggers", ":=", "make", "(", "[", "]", "*", "internal", ".", "Trigger", ",", "0", ",", "len", "(", "op", ".", "readyTriggers", ")", ")", "\n", "for", "_", ",", "t", ":=", "range", "op", ".", "readyTriggers", "{", "if", "popOp", ".", "CanPop", "(", "t", ".", "Id", ")", "{", "triggers", "=", "append", "(", "triggers", ",", "t", ")", "\n", "}", "\n", "}", "\n", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ",", "len", "(", "triggers", ")", ")", "\n\n", "// If the job is paused or disabled, just pop all triggers without starting", "// anything. Note: there's a best-effort shortcut for ignoring triggers", "// for paused jobs in execEnqueueTriggersTask.", "if", "len", "(", "triggers", ")", "!=", "0", "{", "if", "job", ".", "Paused", "||", "!", "job", ".", "Enabled", "{", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ")", "\n", "for", "_", ",", "t", ":=", "range", "triggers", "{", "popOp", ".", "Pop", "(", "t", ".", "Id", ")", "\n", "}", "\n", "return", "popOp", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Keep the set of pending triggers bounded, to avoid total meltdown caused", "// by slow triage transactions.", "if", "len", "(", "triggers", ")", ">", "op", ".", "maxAllowedTriggers", "{", "dropping", ":=", "len", "(", "triggers", ")", "-", "op", ".", "maxAllowedTriggers", "\n", "op", ".", "debugErrLog", "(", "c", ",", "nil", ",", "\"", "\"", ",", "op", ".", "maxAllowedTriggers", ",", "dropping", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "dropping", ";", "i", "++", "{", "popOp", ".", "Pop", "(", "triggers", "[", "i", "]", ".", "Id", ")", "\n", "}", "\n", "triggers", "=", "triggers", "[", "dropping", ":", "]", "\n", "}", "\n\n", "// Ask the policy to convert triggers into invocations. Note that triggers is", "// not the only input to the triggering policy, so we call it on each triage,", "// even if there's no pending triggers.", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ")", "\n", "out", ":=", "op", ".", "triggeringPolicy", "(", "c", ",", "job", ",", "triggers", ")", "\n", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ",", "len", "(", "out", ".", "Requests", ")", ")", "\n\n", "// Actually pop all consumed triggers and start the corresponding invocations.", "// Note that this modifies job.ActiveInvocations list.", "if", "len", "(", "out", ".", "Requests", ")", "!=", "0", "{", "consumed", ":=", "0", "\n", "for", "_", ",", "r", ":=", "range", "out", ".", "Requests", "{", "for", "_", ",", "t", ":=", "range", "r", ".", "IncomingTriggers", "{", "popOp", ".", "Pop", "(", "t", ".", "Id", ")", "\n", "}", "\n", "consumed", "+=", "len", "(", "r", ".", "IncomingTriggers", ")", "\n", "}", "\n", "if", "err", ":=", "op", ".", "enqueueInvocations", "(", "c", ",", "job", ",", "out", ".", "Requests", ")", ";", "err", "!=", "nil", "{", "op", ".", "debugErrLog", "(", "c", ",", "err", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "op", ".", "debugInfoLog", "(", "c", ",", "\"", "\"", ",", "consumed", ")", "\n", "}", "\n\n", "return", "popOp", ",", "nil", "\n", "}" ]

[ "processTriggers", "pops", "pending", "triggers", "converting", "them", "into", "invocations", "." ]

[ "func", "(", "op", "*", "triageOp", ")", "triggeringPolicy", "(", "c", "context", ".", "Context", ",", "job", "*", "Job", ",", "triggers", "[", "]", "*", "internal", ".", "Trigger", ")", "policy", ".", "Out", "{", "var", "policyFunc", "policy", ".", "Func", "\n", "p", ",", "err", ":=", "policy", ".", "UnmarshalDefinition", "(", "job", ".", "TriggeringPolicyRaw", ")", "\n", "if", "err", "==", "nil", "{", "policyFunc", ",", "err", "=", "op", ".", "policyFactory", "(", "p", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "op", ".", "debugErrLog", "(", "c", ",", "err", ",", "\"", "\"", ")", "\n", "policyFunc", "=", "policy", ".", "Default", "(", ")", "\n", "}", "\n", "return", "policyFunc", "(", "policyFuncEnv", "{", "c", ",", "op", "}", ",", "policy", ".", "In", "{", "Now", ":", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", ",", "ActiveInvocations", ":", "job", ".", "ActiveInvocations", ",", "Triggers", ":", "triggers", ",", "}", ")", "\n", "}" ]

[ "triggeringPolicy", "decides", "how", "to", "convert", "a", "set", "of", "pending", "triggers", "into", "a", "bunch", "of", "new", "invocations", ".", "Called", "within", "a", "job", "transaction", ".", "Must", "not", "do", "any", "expensive", "calls", "." ]

[ "func", "New", "(", "l", "sync", ".", "Locker", ")", "*", "Cond", "{", "return", "&", "Cond", "{", "Cond", ":", "sync", ".", "NewCond", "(", "l", ")", ",", "}", "\n", "}" ]

[ "New", "creates", "a", "new", "Context", "-", "cancellable", "Cond", "." ]

[ "func", "UseFlex", "(", "c", "context", ".", "Context", ")", "context", ".", "Context", "{", "// TODO: Install a path to load configurations from datastore cache. ATM,", "// it can't be done because using datastore cache requires the ability to", "// write to datastore.", "ccfg", ":=", "cacheConfig", "{", "GlobalCache", ":", "func", "(", "c", "context", ".", "Context", ",", "be", "backend", ".", "B", ",", "s", "*", "Settings", ")", "backend", ".", "B", "{", "return", "caching", ".", "LRUBackend", "(", "be", ",", "configProcCache", ".", "LRU", "(", "c", ")", ",", "s", ".", "CacheExpiration", "(", ")", ")", "\n", "}", ",", "}", "\n", "return", "installConfigBackend", "(", "c", ",", "mustFetchCachedSettings", "(", "c", ")", ",", "nil", ",", "ccfg", ")", "\n", "}" ]

[ "UseFlex", "installs", "the", "default", "luci", "-", "config", "client", "for", "an", "AppEngine", "Flex", "environment", ".", "UseFlex", "has", "the", "same", "effect", "as", "Use", "except", "that", "the", "backing", "cache", "is", "a", "process", "-", "local", "cache", "instead", "of", "the", "AppEngine", "memcache", "service", "." ]

[ "func", "devServerBackend", "(", ")", "backend", ".", "B", "{", "pwd", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "// os.Getwd works funny with symlinks, use PWD", "\n", "candidates", ":=", "[", "]", "string", "{", "filepath", ".", "Join", "(", "pwd", ",", "devCfgDir", ")", ",", "filepath", ".", "Join", "(", "filepath", ".", "Dir", "(", "pwd", ")", ",", "devCfgDir", ")", ",", "}", "\n", "for", "_", ",", "dir", ":=", "range", "candidates", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "dir", ")", ";", "err", "==", "nil", "{", "fs", ",", "err", ":=", "filesystem", ".", "New", "(", "dir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "erroring", ".", "New", "(", "err", ")", "\n", "}", "\n", "return", "&", "client", ".", "Backend", "{", "&", "testconfig", ".", "Provider", "{", "Base", ":", "fs", ",", "}", "}", "\n", "}", "\n", "}", "\n", "return", "erroring", ".", "New", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "candidates", ")", ")", "\n", "}" ]

[ "devServerConfig", "returns", "backend", ".", "B", "to", "use", "on", "a", "devserver", ".", "See", "New", "for", "details", "." ]

[ "func", "Archive", "(", "ctx", "context", ".", "Context", ",", "arch", "*", "archiver", ".", "Archiver", ",", "opts", "*", "ArchiveOptions", ")", "*", "archiver", ".", "PendingItem", "{", "item", ",", "err", ":=", "archive", "(", "ctx", ",", "arch", ",", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "i", ":=", "&", "archiver", ".", "PendingItem", "{", "DisplayName", ":", "opts", ".", "Isolated", "}", "\n", "i", ".", "SetErr", "(", "err", ")", "\n", "return", "i", "\n", "}", "\n", "return", "item", "\n", "}" ]

[ "Archive", "uses", "the", "given", "archiver", "and", "options", "to", "constructed", "an", "isolated", "file", "and", "uploads", "it", "and", "its", "dependencies", ".", "Archive", "returns", "the", "digest", "of", "the", "composite", "isolated", "file", "." ]

[ "func", "maybeEnterProjectNamespace", "(", "c", "context", ".", "Context", ",", "req", "proto", ".", "Message", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "if", "pbm", ",", "ok", ":=", "req", ".", "(", "endpoints", ".", "ProjectBoundMessage", ")", ";", "ok", "{", "project", ":=", "types", ".", "ProjectName", "(", "pbm", ".", "GetMessageProject", "(", ")", ")", "\n", "log", ".", "Fields", "{", "\"", "\"", ":", "project", ",", "}", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "if", "err", ":=", "coordinator", ".", "WithProjectNamespace", "(", "&", "c", ",", "project", ",", "coordinator", ".", "NamespaceAccessNoAuth", ")", ";", "err", "!=", "nil", "{", "return", "c", ",", "err", "\n", "}", "\n", "}", "\n", "return", "c", ",", "nil", "\n", "}" ]

[ "maybeEnterProjectNamespace", "enters", "a", "datastore", "namespace", "based", "on", "the", "request", "message", "type", "." ]

[ "func", "(", "b", "*", "BackDep", ")", "Edge", "(", ")", "*", "FwdEdge", "{", "ret", ":=", "&", "FwdEdge", "{", "From", ":", "&", "b", ".", "Depender", ",", "To", ":", "&", "dm", ".", "Attempt_ID", "{", "}", "}", "\n", "if", "err", ":=", "ret", ".", "To", ".", "SetDMEncoded", "(", "b", ".", "DependeeGroup", ".", "StringID", "(", ")", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "Edge", "produces", "a", "fwdedge", "object", "which", "points", "from", "the", "depending", "attempt", "to", "the", "depended", "-", "on", "attempt", "." ]

[ "func", "Main", "(", "params", "base", ".", "Parameters", ",", "args", "[", "]", "string", ")", "int", "{", "// Enable not-yet-standard Starlark features.", "resolve", ".", "AllowLambda", "=", "true", "\n", "resolve", ".", "AllowNestedDef", "=", "true", "\n", "resolve", ".", "AllowFloat", "=", "true", "\n", "resolve", ".", "AllowSet", "=", "true", "\n\n", "// A hack to allow '#!/usr/bin/env lucicfg'. On Linux the shebang line can", "// have at most two arguments, so we can't use '#!/usr/bin/env lucicfg gen'.", "if", "len", "(", "args", ")", "==", "1", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "args", "[", "0", "]", ")", ";", "err", "==", "nil", "{", "args", "=", "[", "]", "string", "{", "\"", "\"", ",", "args", "[", "0", "]", "}", "\n", "}", "\n", "}", "\n\n", "return", "subcommands", ".", "Run", "(", "GetApplication", "(", "params", ")", ",", "fixflagpos", ".", "FixSubcommands", "(", "args", ")", ")", "\n", "}" ]

[ "Main", "runs", "the", "lucicfg", "CLI", "." ]

[ "func", "GetApplication", "(", "params", "base", ".", "Parameters", ")", "*", "cli", ".", "Application", "{", "return", "&", "cli", ".", "Application", "{", "Name", ":", "\"", "\"", ",", "Title", ":", "\"", "\"", "+", "lucicfg", ".", "UserAgent", "+", "\"", "\"", ",", "Context", ":", "func", "(", "ctx", "context", ".", "Context", ")", "context", ".", "Context", "{", "loggerConfig", ":=", "gologger", ".", "LoggerConfig", "{", "Format", ":", "`[P%{pid} %{time:15:04:05.000} %{shortfile} %{level:.1s}] %{message}`", ",", "Out", ":", "os", ".", "Stderr", ",", "}", "\n", "return", "loggerConfig", ".", "Use", "(", "ctx", ")", "\n", "}", ",", "Commands", ":", "[", "]", "*", "subcommands", ".", "Command", "{", "subcommands", ".", "Section", "(", "\"", "\\n", "\"", ")", ",", "generate", ".", "Cmd", "(", "params", ")", ",", "validate", ".", "Cmd", "(", "params", ")", ",", "subcommands", ".", "Section", "(", "\"", "\\n", "\"", ")", ",", "diff", ".", "Cmd", "(", "params", ")", ",", "subcommands", ".", "Section", "(", "\"", "\\n", "\"", ")", ",", "authcli", ".", "SubcommandInfo", "(", "params", ".", "AuthOptions", ",", "\"", "\"", ",", "true", ")", ",", "authcli", ".", "SubcommandLogin", "(", "params", ".", "AuthOptions", ",", "\"", "\"", ",", "false", ")", ",", "authcli", ".", "SubcommandLogout", "(", "params", ".", "AuthOptions", ",", "\"", "\"", ",", "false", ")", ",", "subcommands", ".", "Section", "(", "\"", "\\n", "\"", ")", ",", "subcommands", ".", "CmdHelp", ",", "versioncli", ".", "CmdVersion", "(", "lucicfg", ".", "UserAgent", ")", ",", "}", ",", "}", "\n", "}" ]

[ "GetApplication", "returns", "lucicfg", "cli", ".", "Application", "." ]

[ "func", "makeSessionCookie", "(", "c", "context", ".", "Context", ",", "sid", "string", ",", "secure", "bool", ")", "(", "*", "http", ".", "Cookie", ",", "error", ")", "{", "tok", ",", "err", ":=", "sessionCookieToken", ".", "Generate", "(", "c", ",", "nil", ",", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "sid", "}", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Make cookie expire a bit earlier, to avoid weird \"bad token\" errors if", "// clocks are out of sync.", "exp", ":=", "sessionCookieToken", ".", "Expiration", "-", "15", "*", "time", ".", "Minute", "\n", "return", "&", "http", ".", "Cookie", "{", "Name", ":", "sessionCookieName", ",", "Value", ":", "tok", ",", "Path", ":", "\"", "\"", ",", "Secure", ":", "secure", ",", "HttpOnly", ":", "true", ",", "// no access from Javascript", "Expires", ":", "clock", ".", "Now", "(", "c", ")", ".", "Add", "(", "exp", ")", ",", "MaxAge", ":", "int", "(", "exp", "/", "time", ".", "Second", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "makeSessionCookie", "takes", "a", "session", "ID", "and", "makes", "a", "signed", "cookie", "that", "can", "be", "put", "in", "a", "response", "." ]

[ "func", "decodeSessionCookie", "(", "c", "context", ".", "Context", ",", "r", "*", "http", ".", "Request", ")", "(", "string", ",", "error", ")", "{", "cookie", ",", "err", ":=", "r", ".", "Cookie", "(", "sessionCookieName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", "// no such cookie", "\n", "}", "\n", "payload", ",", "err", ":=", "sessionCookieToken", ".", "Validate", "(", "c", ",", "cookie", ".", "Value", ",", "nil", ")", "\n", "switch", "{", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", ":", "return", "\"", "\"", ",", "err", "\n", "case", "err", "!=", "nil", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "cookie", ".", "Value", ",", "err", ")", "\n", "return", "\"", "\"", ",", "nil", "\n", "case", "payload", "[", "\"", "\"", "]", "==", "\"", "\"", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "payload", ")", "\n", "return", "\"", "\"", ",", "nil", "\n", "}", "\n", "return", "payload", "[", "\"", "\"", "]", ",", "nil", "\n", "}" ]

[ "decodeSessionCookie", "takes", "an", "incoming", "request", "and", "returns", "a", "session", "ID", "stored", "in", "a", "session", "cookie", "or", "if", "not", "there", "invalid", "or", "expired", ".", "Returns", "errors", "on", "transient", "errors", "only", "." ]

[ "func", "Enable", "(", "server", "*", "prpc", ".", "Server", ")", "{", "serviceNames", ":=", "append", "(", "server", ".", "ServiceNames", "(", ")", ",", "\"", "\"", ")", "\n", "service", ",", "err", ":=", "New", "(", "serviceNames", "...", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "RegisterDiscoveryServer", "(", "server", ",", "service", ")", "\n", "}" ]

[ "Enable", "registers", "a", "discovery", "service", "on", "the", "server", ".", "It", "makes", "all", "currently", "registered", "services", "and", "the", "discovery", "service", "discoverable", "." ]

[ "func", "combineDescriptors", "(", "serviceNames", "[", "]", "string", ")", "(", "*", "descriptor", ".", "FileDescriptorSet", ",", "error", ")", "{", "result", ":=", "&", "descriptor", ".", "FileDescriptorSet", "{", "}", "\n", "// seenFiles is a set of descriptor files keyed by SHA256 of their contents.", "seenFiles", ":=", "map", "[", "[", "sha256", ".", "Size", "]", "byte", "]", "bool", "{", "}", "\n\n", "for", "_", ",", "s", ":=", "range", "serviceNames", "{", "desc", ",", "err", ":=", "GetDescriptorSet", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ",", "err", ")", "\n", "}", "\n", "if", "desc", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "s", ")", "\n", "}", "\n", "for", "_", ",", "f", ":=", "range", "desc", ".", "GetFile", "(", ")", "{", "binary", ",", "err", ":=", "proto", ".", "Marshal", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "f", ".", "GetName", "(", ")", ")", "\n", "}", "\n", "hash", ":=", "sha256", ".", "Sum256", "(", "binary", ")", "\n", "if", "!", "seenFiles", "[", "hash", "]", "{", "result", ".", "File", "=", "append", "(", "result", ".", "File", ",", "f", ")", "\n", "seenFiles", "[", "hash", "]", "=", "true", "\n", "}", "\n\n", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "combineDescriptors", "creates", "one", "FileDescriptorSet", "that", "covers", "all", "services", "and", "their", "dependencies", "." ]

[ "func", "NewFields", "(", "v", "map", "[", "string", "]", "interface", "{", "}", ")", "Fields", "{", "fields", ":=", "make", "(", "Fields", ")", "\n", "for", "k", ",", "v", ":=", "range", "v", "{", "fields", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "fields", "\n", "}" ]

[ "NewFields", "instantiates", "a", "new", "Fields", "instance", "by", "duplicating", "the", "supplied", "map", "." ]

[ "func", "(", "f", "Fields", ")", "Copy", "(", "other", "Fields", ")", "Fields", "{", "if", "len", "(", "f", ")", "==", "0", "&&", "len", "(", "other", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "ret", ":=", "make", "(", "Fields", ",", "len", "(", "f", ")", "+", "len", "(", "other", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "f", "{", "ret", "[", "k", "]", "=", "v", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "other", "{", "ret", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "Copy", "returns", "a", "copy", "of", "this", "Fields", "with", "the", "keys", "from", "other", "overlaid", "on", "top", "of", "this", "one", "s", "." ]

[ "func", "(", "f", "Fields", ")", "SortedEntries", "(", ")", "(", "s", "[", "]", "*", "FieldEntry", ")", "{", "if", "len", "(", "f", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "s", "=", "make", "(", "[", "]", "*", "FieldEntry", ",", "0", ",", "len", "(", "f", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "f", "{", "s", "=", "append", "(", "s", ",", "&", "FieldEntry", "{", "k", ",", "v", "}", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "fieldEntrySlice", "(", "s", ")", ")", "\n", "return", "\n", "}" ]

[ "SortedEntries", "processes", "a", "Fields", "object", "pruning", "invisible", "fields", "placing", "the", "ErrorKey", "field", "first", "and", "then", "sorting", "the", "remaining", "fields", "by", "key", "." ]

[ "func", "(", "f", "Fields", ")", "String", "(", ")", "string", "{", "b", ":=", "bytes", ".", "Buffer", "{", "}", "\n", "b", ".", "WriteRune", "(", "'{'", ")", "\n", "for", "idx", ",", "e", ":=", "range", "f", ".", "SortedEntries", "(", ")", "{", "if", "idx", ">", "0", "{", "b", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n", "b", ".", "WriteString", "(", "e", ".", "String", "(", ")", ")", "\n", "}", "\n", "b", ".", "WriteRune", "(", "'}'", ")", "\n", "return", "b", ".", "String", "(", ")", "\n", "}" ]

[ "String", "returns", "a", "string", "describing", "the", "contents", "of", "f", "in", "a", "sorted", "dictionary", "-", "like", "format", "." ]

[ "func", "GetFields", "(", "c", "context", ".", "Context", ")", "Fields", "{", "if", "ret", ",", "ok", ":=", "c", ".", "Value", "(", "fieldsKey", ")", ".", "(", "Fields", ")", ";", "ok", "{", "return", "ret", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetFields", "returns", "the", "current", "Fields", ".", "This", "method", "is", "used", "for", "logger", "implementations", "with", "the", "understanding", "that", "the", "returned", "fields", "must", "not", "be", "mutated", "." ]

[ "func", "WithProject", "(", "ctx", "context", ".", "Context", ",", "project", "string", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "&", "luciProjectKey", ",", "project", ")", "\n", "}" ]

[ "WithProject", "annotates", "the", "context", "object", "with", "the", "LUCI", "project", "that", "a", "request", "is", "handled", "for", "." ]

[ "func", "ProjectFromContext", "(", "ctx", "context", ".", "Context", ")", "(", "string", ",", "error", ")", "{", "project", ",", "ok", ":=", "ctx", ".", "Value", "(", "&", "luciProjectKey", ")", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "project", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "project", ",", "nil", "\n", "}" ]

[ "ProjectFromContext", "is", "the", "opposite", "of", "WithProject", "is", "extracts", "the", "LUCI", "project", "which", "the", "current", "call", "stack", "is", "handling", "a", "request", "for", "." ]

[ "func", "decodeKey", "(", "k", "string", ")", "(", "string", ",", "error", ")", "{", "if", "!", "strings", ".", "HasPrefix", "(", "k", ",", "encodedKeyPrefix", ")", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "encodedKeyPrefix", ")", "\n", "}", "\n\n", "data", ",", "err", ":=", "keyEncoding", ".", "DecodeString", "(", "k", "[", "len", "(", "encodedKeyPrefix", ")", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "string", "(", "data", ")", ",", "nil", "\n", "}" ]

[ "decodeKey", "converts", "an", "encoded", "key", "into", "its", "original", "key", "string", "." ]

[ "func", "(", "id", "*", "HashID", ")", "Normalize", "(", ")", "error", "{", "// encoding/hex encodes using lower-case hexadecimal. Note that this is a", "// no-op if the ID is already lowercase.", "idv", ":=", "strings", ".", "ToLower", "(", "string", "(", "*", "id", ")", ")", "\n\n", "if", "decodeSize", ":=", "hex", ".", "DecodedLen", "(", "len", "(", "idv", ")", ")", ";", "decodeSize", "!=", "sha256", ".", "Size", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "decodeSize", ",", "sha256", ".", "Size", ")", "\n", "}", "\n", "for", "i", ",", "r", ":=", "range", "idv", "{", "if", "!", "strings", ".", "ContainsRune", "(", "validHashIDChars", ",", "r", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ",", "i", ")", "\n", "}", "\n", "}", "\n", "*", "id", "=", "HashID", "(", "idv", ")", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "normalizes", "the", "hash", "ID", "and", "verifies", "its", "integrity", "." ]

[ "func", "(", "l", "*", "Log", ")", "projID", "(", "ctx", "context", ".", "Context", ")", "string", "{", "if", "l", ".", "ProjectID", "==", "\"", "\"", "{", "return", "info", ".", "TrimmedAppID", "(", "ctx", ")", "\n", "}", "\n", "return", "l", ".", "ProjectID", "\n", "}" ]

[ "projID", "returns", "ProjectID", "or", "a", "GAE", "app", "ID", "if", "ProjectID", "is", "." ]

[ "func", "(", "l", "*", "Log", ")", "tableRef", "(", "ctx", "context", ".", "Context", ")", "(", "string", ",", "error", ")", "{", "projID", ":=", "l", ".", "projID", "(", "ctx", ")", "\n", "if", "projID", "==", "\"", "\"", "||", "strings", ".", "ContainsRune", "(", "projID", ",", "'/'", ")", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "projID", ")", "\n", "}", "\n", "if", "l", ".", "DatasetID", "==", "\"", "\"", "||", "strings", ".", "ContainsRune", "(", "l", ".", "DatasetID", ",", "'/'", ")", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "l", ".", "DatasetID", ")", "\n", "}", "\n", "if", "l", ".", "TableID", "==", "\"", "\"", "||", "strings", ".", "ContainsRune", "(", "l", ".", "TableID", ",", "'/'", ")", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "l", ".", "TableID", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "projID", ",", "l", ".", "DatasetID", ",", "l", ".", "TableID", ")", ",", "nil", "\n", "}" ]

[ "tableRef", "returns", "an", "identifier", "of", "the", "table", "in", "BigQuery", ".", "Returns", "an", "error", "if", "Log", "is", "misconfigred", "." ]

[ "func", "(", "l", "*", "Log", ")", "bigQuery", "(", "ctx", "context", ".", "Context", ")", "(", "*", "bqapi", ".", "Service", ",", "error", ")", "{", "tr", ",", "err", ":=", "auth", ".", "GetRPCTransport", "(", "ctx", ",", "auth", ".", "AsSelf", ",", "auth", ".", "WithScopes", "(", "bqapi", ".", "BigqueryScope", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "bqapi", ".", "New", "(", "&", "http", ".", "Client", "{", "Transport", ":", "tr", "}", ")", "\n", "}" ]

[ "bigQuery", "constructs", "an", "instance", "of", "BigQuery", "API", "client", "with", "proper", "auth", "." ]

[ "func", "(", "l", "*", "Log", ")", "doInsert", "(", "ctx", "context", ".", "Context", ",", "req", "*", "bqapi", ".", "TableDataInsertAllRequest", ")", "(", "*", "bqapi", ".", "TableDataInsertAllResponse", ",", "error", ")", "{", "ctx", ",", "_", "=", "clock", ".", "WithTimeout", "(", "ctx", ",", "30", "*", "time", ".", "Second", ")", "\n", "logging", ".", "Infof", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "req", ".", "Rows", ")", ")", "\n", "bq", ",", "err", ":=", "l", ".", "bigQuery", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "call", ":=", "bq", ".", "Tabledata", ".", "InsertAll", "(", "l", ".", "projID", "(", "ctx", ")", ",", "l", ".", "DatasetID", ",", "l", ".", "TableID", ",", "req", ")", "\n", "return", "call", ".", "Context", "(", "ctx", ")", ".", "Do", "(", ")", "\n", "}" ]

[ "doInsert", "does", "the", "actual", "BigQuery", "call", ".", "It", "is", "mocked", "in", "tests", "." ]

[ "func", "(", "f", "*", "asyncFlusher", ")", "start", "(", "numParallel", "int", ")", "{", "f", ".", "chunks", "=", "make", "(", "chan", "chunk", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "numParallel", ";", "i", "++", "{", "f", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "defer", "f", ".", "wg", ".", "Done", "(", ")", "\n", "f", ".", "uploaderLoop", "(", ")", "\n", "}", "(", ")", "\n", "}", "\n", "}" ]

[ "start", "launches", "internal", "goroutines", "that", "upload", "data", "." ]

[ "func", "(", "f", "*", "asyncFlusher", ")", "waitAll", "(", ")", "(", "int", ",", "error", ")", "{", "close", "(", "f", ".", "chunks", ")", "\n", "f", ".", "wg", ".", "Wait", "(", ")", "\n", "if", "len", "(", "f", ".", "errs", ")", "==", "0", "{", "return", "f", ".", "rowsSent", ",", "nil", "\n", "}", "\n", "return", "f", ".", "rowsSent", ",", "f", ".", "errs", "\n", "}" ]

[ "waitAll", "waits", "for", "completion", "of", "all", "pending", "sendChunk", "calls", "and", "stops", "all", "internal", "goroutines", ".", "Returns", "total", "number", "of", "rows", "sent", "and", "all", "the", "errors", "." ]

[ "func", "(", "f", "*", "asyncFlusher", ")", "ctx", "(", "chunkIndex", "int32", ")", "context", ".", "Context", "{", "return", "logging", ".", "SetField", "(", "f", ".", "Context", ",", "\"", "\"", ",", "chunkIndex", ")", "\n", "}" ]

[ "ctx", "returns", "a", "context", "to", "use", "for", "logging", "operations", "happening", "to", "some", "chunk", "." ]

[ "func", "(", "f", "*", "asyncFlusher", ")", "sendChunk", "(", "c", "chunk", ")", "{", "c", ".", "index", "=", "atomic", ".", "AddInt32", "(", "&", "f", ".", "index", ",", "1", ")", "\n", "logging", ".", "Infof", "(", "f", ".", "ctx", "(", "c", ".", "index", ")", ",", "\"", "\"", ",", "len", "(", "c", ".", "Tasks", ")", ")", "\n", "f", ".", "chunks", "<-", "c", "\n", "}" ]

[ "sendChunk", "starts", "an", "asynchronous", "operation", "to", "upload", "data", "to", "BigQuery", ".", "Can", "block", "if", "too", "many", "parallel", "uploads", "are", "already", "underway", ".", "Panics", "if", "called", "before", "start", "or", "after", "waitAll", ".", "On", "successful", "upload", "it", "deletes", "the", "tasks", "from", "Pull", "Queue", "." ]

[ "func", "(", "f", "*", "asyncFlusher", ")", "uploaderLoop", "(", ")", "{", "for", "chunk", ":=", "range", "f", ".", "chunks", "{", "ctx", ":=", "f", ".", "ctx", "(", "chunk", ".", "index", ")", "\n", "logging", ".", "Infof", "(", "ctx", ",", "\"", "\"", ")", "\n", "sent", ",", "err", ":=", "f", ".", "upload", "(", "ctx", ",", "chunk", ")", "\n", "f", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "err", "==", "nil", "{", "f", ".", "rowsSent", "+=", "sent", "\n", "}", "else", "{", "f", ".", "errs", "=", "append", "(", "f", ".", "errs", ",", "err", ")", "\n", "}", "\n", "f", ".", "mu", ".", "Unlock", "(", ")", "\n", "logging", ".", "Infof", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "uploaderLoop", "runs", "in", "a", "separate", "goroutine", "." ]

[ "func", "(", "b", "NamedBlob", ")", "Clone", "(", ")", "NamedBlob", "{", "return", "NamedBlob", "{", "ID", ":", "b", ".", "ID", ",", "Blob", ":", "append", "(", "[", "]", "byte", "(", "nil", ")", ",", "b", ".", "Blob", "...", ")", ",", "}", "\n", "}" ]

[ "Clone", "makes", "a", "deep", "copy", "of", "the", "NamedBlob", "." ]

[ "func", "(", "s", "Secret", ")", "Blobs", "(", ")", "[", "]", "NamedBlob", "{", "out", ":=", "make", "(", "[", "]", "NamedBlob", ",", "0", ",", "1", "+", "len", "(", "s", ".", "Previous", ")", ")", "\n", "out", "=", "append", "(", "out", ",", "s", ".", "Current", ")", "\n", "out", "=", "append", "(", "out", ",", "s", ".", "Previous", "...", ")", "\n", "return", "out", "\n", "}" ]

[ "Blobs", "returns", "current", "blob", "and", "all", "previous", "blobs", "as", "one", "array", "." ]

[ "func", "(", "s", "Secret", ")", "Clone", "(", ")", "Secret", "{", "out", ":=", "Secret", "{", "Current", ":", "s", ".", "Current", ".", "Clone", "(", ")", "}", "\n", "if", "s", ".", "Previous", "!=", "nil", "{", "out", ".", "Previous", "=", "make", "(", "[", "]", "NamedBlob", ",", "len", "(", "s", ".", "Previous", ")", ")", "\n", "for", "i", ":=", "range", "out", ".", "Previous", "{", "out", ".", "Previous", "[", "i", "]", "=", "s", ".", "Previous", "[", "i", "]", ".", "Clone", "(", ")", "\n", "}", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "Clone", "makes", "a", "deep", "copy", "of", "the", "Secret", "." ]

[ "func", "(", "s", "StaticStore", ")", "GetSecret", "(", "k", "Key", ")", "(", "Secret", ",", "error", ")", "{", "if", "secret", ",", "ok", ":=", "s", "[", "k", "]", ";", "ok", "{", "return", "secret", ".", "Clone", "(", ")", ",", "nil", "\n", "}", "\n", "return", "Secret", "{", "}", ",", "ErrNoSuchSecret", "\n", "}" ]

[ "GetSecret", "returns", "a", "copy", "of", "a", "secret", "given", "its", "key", "or", "ErrNoSuchSecret", "if", "no", "such", "secret", "." ]

[ "func", "HumanDuration", "(", "d", "time", ".", "Duration", ")", "string", "{", "t", ":=", "int64", "(", "d", ".", "Seconds", "(", ")", ")", "\n", "day", ":=", "t", "/", "86400", "\n", "hr", ":=", "(", "t", "%", "86400", ")", "/", "3600", "\n\n", "if", "day", ">", "0", "{", "if", "hr", "!=", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "day", ",", "hr", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "day", ")", "\n", "}", "\n\n", "min", ":=", "(", "t", "%", "3600", ")", "/", "60", "\n", "if", "hr", ">", "0", "{", "if", "min", "!=", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "hr", ",", "min", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "hr", ")", "\n", "}", "\n\n", "sec", ":=", "t", "%", "60", "\n", "if", "min", ">", "0", "{", "if", "sec", "!=", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "min", ",", "sec", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "min", ")", "\n", "}", "\n\n", "if", "sec", "!=", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sec", ")", "\n", "}", "\n\n", "if", "d", ">", "time", ".", "Millisecond", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "d", "/", "time", ".", "Millisecond", ")", "\n", "}", "\n\n", "return", "\"", "\"", "\n", "}" ]

[ "humanDuration", "translates", "d", "into", "a", "human", "readable", "string", "of", "x", "units", "y", "units", "where", "x", "and", "y", "could", "be", "in", "days", "hours", "minutes", "or", "seconds", "whichever", "is", "the", "largest", "." ]

[ "func", "(", "s", "*", "Settings", ")", "Load", "(", "c", "context", ".", "Context", ")", "error", "{", "var", "loadMe", "Settings", "\n\n", "// Load additional global config from settings. If it's missing, that's fine,", "// since its fields are all optional.", "if", "err", ":=", "settings", ".", "Get", "(", "c", ",", "globalConfigSettingsKey", ",", "&", "loadMe", ")", ";", "err", "!=", "nil", "{", "// The settings are missing, so let's install the empty settings.", "if", "err", "!=", "settings", ".", "ErrNoSettings", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "settings", ".", "Set", "(", "c", ",", "globalConfigSettingsKey", ",", "&", "loadMe", ",", "\"", "\"", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "*", "s", "=", "loadMe", "\n", "return", "nil", "\n", "}" ]

[ "Load", "populates", "the", "settings", "instance", "from", "the", "stored", "settings", ".", "If", "no", "settings", "are", "stored", "an", "empty", "Settings", "instance", "will", "be", "loaded", "and", "this", "will", "return", "nil", ".", "An", "error", "will", "be", "returned", "if", "an", "operation", "that", "is", "expected", "to", "succeed", "fails", "." ]

[ "func", "(", "s", "*", "Settings", ")", "Store", "(", "c", "context", ".", "Context", ",", "why", "string", ")", "error", "{", "id", ":=", "auth", ".", "CurrentIdentity", "(", "c", ")", "\n", "log", ".", "Fields", "{", "\"", "\"", ":", "id", ",", "\"", "\"", ":", "why", ",", "}", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "return", "settings", ".", "Set", "(", "c", ",", "globalConfigSettingsKey", ",", "s", ",", "string", "(", "id", ")", ",", "why", ")", "\n", "}" ]

[ "Store", "stores", "the", "new", "global", "configuration", "." ]

[ "func", "(", "t", "*", "DatacentersTable", ")", "fetch", "(", "c", "context", ".", "Context", ")", "error", "{", "db", ":=", "database", ".", "Get", "(", "c", ")", "\n", "rows", ",", "err", ":=", "db", ".", "QueryContext", "(", "c", ",", "`\n\t\tSELECT id, name, description, state\n\t\tFROM datacenters\n\t`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n", "for", "rows", ".", "Next", "(", ")", "{", "dc", ":=", "&", "Datacenter", "{", "}", "\n", "if", "err", ":=", "rows", ".", "Scan", "(", "&", "dc", ".", "Id", ",", "&", "dc", ".", "Name", ",", "&", "dc", ".", "Description", ",", "&", "dc", ".", "State", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "t", ".", "current", "=", "append", "(", "t", ".", "current", ",", "dc", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "fetch", "fetches", "the", "datacenters", "from", "the", "database", "." ]

[ "func", "(", "t", "*", "DatacentersTable", ")", "computeChanges", "(", "c", "context", ".", "Context", ",", "datacenters", "[", "]", "*", "config", ".", "Datacenter", ")", "{", "cfgs", ":=", "make", "(", "map", "[", "string", "]", "*", "Datacenter", ",", "len", "(", "datacenters", ")", ")", "\n", "for", "_", ",", "cfg", ":=", "range", "datacenters", "{", "cfgs", "[", "cfg", ".", "Name", "]", "=", "&", "Datacenter", "{", "Datacenter", ":", "config", ".", "Datacenter", "{", "Name", ":", "cfg", ".", "Name", ",", "Description", ":", "cfg", ".", "Description", ",", "State", ":", "cfg", ".", "State", ",", "}", ",", "}", "\n", "}", "\n\n", "for", "_", ",", "dc", ":=", "range", "t", ".", "current", "{", "if", "cfg", ",", "ok", ":=", "cfgs", "[", "dc", ".", "Name", "]", ";", "ok", "{", "// Datacenter found in the config.", "if", "t", ".", "needsUpdate", "(", "dc", ",", "cfg", ")", "{", "// Datacenter doesn't match the config.", "cfg", ".", "Id", "=", "dc", ".", "Id", "\n", "t", ".", "updates", "=", "append", "(", "t", ".", "updates", ",", "cfg", ")", "\n", "}", "\n", "// Record that the datacenter config has been seen.", "delete", "(", "cfgs", ",", "cfg", ".", "Name", ")", "\n", "}", "else", "{", "// Datacenter not found in the config.", "t", ".", "removals", "=", "append", "(", "t", ".", "removals", ",", "dc", ")", "\n", "}", "\n", "}", "\n\n", "// Datacenters remaining in the map are present in the config but not the database.", "// Iterate deterministically over the slice to determine which datacenters need to be added.", "for", "_", ",", "cfg", ":=", "range", "datacenters", "{", "if", "dc", ",", "ok", ":=", "cfgs", "[", "cfg", ".", "Name", "]", ";", "ok", "{", "t", ".", "additions", "=", "append", "(", "t", ".", "additions", ",", "dc", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "computeChanges", "computes", "the", "changes", "that", "need", "to", "be", "made", "to", "the", "datacenters", "in", "the", "database", "." ]

[ "func", "(", "t", "*", "DatacentersTable", ")", "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 datacenters\n\t\tWHERE id = ?\n\t`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "stmt", ".", "Close", "(", ")", "\n\n", "// Remove each datacenter from the table. It's more efficient to update the slice of", "// datacenters 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", "dcs", "[", "]", "*", "Datacenter", "\n", "for", "_", ",", "dc", ":=", "range", "t", ".", "current", "{", "if", "_", ",", "ok", ":=", "removed", "[", "dc", ".", "Id", "]", ";", "!", "ok", "{", "dcs", "=", "append", "(", "dcs", ",", "dc", ")", "\n", "}", "\n", "}", "\n", "t", ".", "current", "=", "dcs", "\n", "}", "(", ")", "\n", "for", "len", "(", "t", ".", "removals", ")", ">", "0", "{", "dc", ":=", "t", ".", "removals", "[", "0", "]", "\n", "if", "_", ",", "err", ":=", "stmt", ".", "ExecContext", "(", "c", ",", "dc", ".", "Id", ")", ";", "err", "!=", "nil", "{", "// Defer ensures the slice of datacenters is updated even if we exit early.", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "dc", ".", "Name", ")", ".", "Err", "(", ")", "\n", "}", "\n", "removed", "[", "dc", ".", "Id", "]", "=", "struct", "{", "}", "{", "}", "\n", "t", ".", "removals", "=", "t", ".", "removals", "[", "1", ":", "]", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "dc", ".", "Name", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "remove", "removes", "all", "datacenters", "pending", "removal", "from", "the", "database", "clearing", "pending", "removals", ".", "No", "-", "op", "unless", "computeChanges", "was", "called", "first", ".", "Idempotent", "until", "computeChanges", "is", "called", "again", "." ]

[ "func", "(", "t", "*", "DatacentersTable", ")", "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 datacenters\n\t\tSET description = ?, state = ?\n\t\tWHERE id = ?\n\t`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "stmt", ".", "Close", "(", ")", "\n\n", "// Update each datacenter in the table. It's more efficient to update the slice of", "// datacenters once at the end rather than for each update, so use a defer.", "updated", ":=", "make", "(", "map", "[", "int64", "]", "*", "Datacenter", ",", "len", "(", "t", ".", "updates", ")", ")", "\n", "defer", "func", "(", ")", "{", "for", "_", ",", "dc", ":=", "range", "t", ".", "current", "{", "if", "u", ",", "ok", ":=", "updated", "[", "dc", ".", "Id", "]", ";", "ok", "{", "dc", ".", "Description", "=", "u", ".", "Description", "\n", "dc", ".", "State", "=", "u", ".", "State", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "for", "len", "(", "t", ".", "updates", ")", ">", "0", "{", "dc", ":=", "t", ".", "updates", "[", "0", "]", "\n", "if", "_", ",", "err", ":=", "stmt", ".", "ExecContext", "(", "c", ",", "dc", ".", "Description", ",", "dc", ".", "State", ",", "dc", ".", "Id", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "dc", ".", "Name", ")", ".", "Err", "(", ")", "\n", "}", "\n", "updated", "[", "dc", ".", "Id", "]", "=", "dc", "\n", "t", ".", "updates", "=", "t", ".", "updates", "[", "1", ":", "]", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "dc", ".", "Name", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "update", "updates", "all", "datacenters", "pending", "update", "in", "the", "database", "clearing", "pending", "updates", ".", "No", "-", "op", "unless", "computeChanges", "was", "called", "first", ".", "Idempotent", "until", "computeChanges", "is", "called", "again", "." ]

[ "func", "(", "t", "*", "DatacentersTable", ")", "ids", "(", "c", "context", ".", "Context", ")", "map", "[", "string", "]", "int64", "{", "dcs", ":=", "make", "(", "map", "[", "string", "]", "int64", ",", "len", "(", "t", ".", "current", ")", ")", "\n", "for", "_", ",", "dc", ":=", "range", "t", ".", "current", "{", "dcs", "[", "dc", ".", "Name", "]", "=", "dc", ".", "Id", "\n", "}", "\n", "return", "dcs", "\n", "}" ]

[ "ids", "returns", "a", "map", "of", "datacenter", "names", "to", "IDs", "." ]

[ "func", "EnsureDatacenters", "(", "c", "context", ".", "Context", ",", "cfgs", "[", "]", "*", "config", ".", "Datacenter", ")", "(", "map", "[", "string", "]", "int64", ",", "error", ")", "{", "t", ":=", "&", "DatacentersTable", "{", "}", "\n", "if", "err", ":=", "t", ".", "fetch", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "t", ".", "computeChanges", "(", "c", ",", "cfgs", ")", "\n", "if", "err", ":=", "t", ".", "add", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "err", ":=", "t", ".", "remove", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "err", ":=", "t", ".", "update", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "t", ".", "ids", "(", "c", ")", ",", "nil", "\n", "}" ]

[ "EnsureDatacenters", "ensures", "the", "database", "contains", "exactly", "the", "given", "datacenters", ".", "Returns", "a", "map", "of", "datacenter", "names", "to", "IDs", "in", "the", "database", "." ]

[ "func", "show", "(", "c", "context", ".", "Context", ",", "client", "*", "prpc", ".", "Client", ",", "name", "string", ")", "error", "{", "desc", ",", "err", ":=", "loadDescription", "(", "c", ",", "client", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "name", "==", "\"", "\"", "{", "for", "_", ",", "s", ":=", "range", "desc", ".", "Services", "{", "fmt", ".", "Println", "(", "s", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "file", ",", "obj", ",", "path", ":=", "descutil", ".", "Resolve", "(", "desc", ".", "Description", ",", "name", ")", "\n", "if", "obj", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "print", ":=", "newPrinter", "(", "os", ".", "Stdout", ")", "\n", "if", "err", ":=", "print", ".", "SetFile", "(", "file", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "switch", "obj", ":=", "obj", ".", "(", "type", ")", "{", "case", "*", "descriptor", ".", "ServiceDescriptorProto", ":", "print", ".", "Service", "(", "obj", ",", "-", "1", ")", "\n\n", "case", "*", "descriptor", ".", "MethodDescriptorProto", ":", "serviceIndex", ",", "methodIndex", ":=", "path", "[", "1", "]", ",", "path", "[", "3", "]", "\n", "print", ".", "Service", "(", "file", ".", "Service", "[", "serviceIndex", "]", ",", "methodIndex", ")", "\n\n", "printMsg", ":=", "func", "(", "name", "string", ")", "error", "{", "name", "=", "strings", ".", "TrimPrefix", "(", "name", ",", "\"", "\"", ")", "\n", "file", ",", "msg", ",", "_", ":=", "descutil", ".", "Resolve", "(", "desc", ".", "Description", ",", "name", ")", "\n", "if", "msg", "==", "nil", "{", "print", ".", "Printf", "(", "\"", "\\n", "\"", ",", "name", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "print", ".", "SetFile", "(", "file", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "print", ".", "Message", "(", "msg", ".", "(", "*", "descriptor", ".", "DescriptorProto", ")", ")", "\n", "return", "nil", "\n", "}", "\n\n", "print", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "if", "err", ":=", "printMsg", "(", "obj", ".", "GetInputType", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "print", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "if", "err", ":=", "printMsg", "(", "obj", ".", "GetOutputType", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "case", "*", "descriptor", ".", "DescriptorProto", ":", "print", ".", "Message", "(", "obj", ")", "\n\n", "case", "*", "descriptor", ".", "FieldDescriptorProto", ":", "print", ".", "Field", "(", "obj", ")", "\n\n", "case", "*", "descriptor", ".", "EnumDescriptorProto", ":", "print", ".", "Enum", "(", "obj", ")", "\n\n", "case", "*", "descriptor", ".", "EnumValueDescriptorProto", ":", "print", ".", "EnumValue", "(", "obj", ")", "\n\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "obj", ")", "\n", "}", "\n\n", "return", "print", ".", "Err", "\n", "}" ]

[ "show", "prints", "a", "definition", "of", "an", "object", "referenced", "by", "name", "in", "proto3", "style", "." ]

[ "func", "(", "r", "*", "IsRevokedCertRPC", ")", "IsRevokedCert", "(", "c", "context", ".", "Context", ",", "req", "*", "admin", ".", "IsRevokedCertRequest", ")", "(", "*", "admin", ".", "IsRevokedCertResponse", ",", "error", ")", "{", "sn", ":=", "big", ".", "Int", "{", "}", "\n", "if", "_", ",", "ok", ":=", "sn", ".", "SetString", "(", "req", ".", "Sn", ",", "0", ")", ";", "!", "ok", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n\n", "checker", ",", "err", ":=", "GetCertChecker", "(", "c", ",", "req", ".", "Ca", ")", "\n", "if", "err", "!=", "nil", "{", "if", "details", ",", "ok", ":=", "err", ".", "(", "Error", ")", ";", "ok", "&&", "details", ".", "Reason", "==", "NoSuchCA", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ",", "req", ".", "Ca", ")", "\n", "}", "\n", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "req", ".", "Ca", ",", "err", ")", "\n", "}", "\n\n", "revoked", ",", "err", ":=", "checker", ".", "CRL", ".", "IsRevokedSN", "(", "c", ",", "&", "sn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "req", ".", "Ca", ",", "err", ")", "\n", "}", "\n\n", "return", "&", "admin", ".", "IsRevokedCertResponse", "{", "Revoked", ":", "revoked", "}", ",", "nil", "\n", "}" ]

[ "IsRevokedCert", "says", "whether", "a", "certificate", "serial", "number", "is", "in", "the", "CRL", "." ]

[ "func", "srcmanCheckout", "(", "c", "context", ".", "Context", ",", "build", "*", "Build", ")", "(", "Checkout", ",", "error", ")", "{", "transport", ",", "err", ":=", "auth", ".", "GetRPCTransport", "(", "c", ",", "auth", ".", "AsSelf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "client", ":=", "coordinator", ".", "NewClient", "(", "&", "prpc", ".", "Client", "{", "C", ":", "&", "http", ".", "Client", "{", "Transport", ":", "transport", "}", ",", "Host", ":", "build", ".", "Infra", ".", "Logdog", ".", "Hostname", ",", "Options", ":", "prpc", ".", "DefaultOptions", "(", ")", ",", "}", ")", "\n", "qo", ":=", "coordinator", ".", "QueryOptions", "{", "ContentType", ":", "srcman", ".", "ContentTypeSourceManifest", ",", "}", "\n", "logProject", ":=", "types", ".", "ProjectName", "(", "build", ".", "Infra", ".", "Logdog", ".", "Project", ")", "\n", "logPath", ":=", "path", ".", "Join", "(", "build", ".", "Infra", ".", "Logdog", ".", "Prefix", ",", "\"", "\"", ")", "\n\n", "// Perform the query, capturing exactly one log stream and erroring otherwise.", "var", "log", "*", "coordinator", ".", "LogStream", "\n", "err", "=", "client", ".", "Query", "(", "c", ",", "logProject", ",", "logPath", ",", "qo", ",", "func", "(", "s", "*", "coordinator", ".", "LogStream", ")", "bool", "{", "log", "=", "s", "\n", "return", "false", "\n", "}", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "return", "nil", ",", "grpcutil", ".", "WrapIfTransient", "(", "err", ")", "\n", "case", "log", "==", "nil", ":", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "build", ".", "Infra", ".", "Logdog", ".", "Project", ",", "logPath", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// Read the source manifest from the log stream.", "var", "buf", "bytes", ".", "Buffer", "\n", "_", ",", "err", "=", "buf", ".", "ReadFrom", "(", "&", "renderer", ".", "Renderer", "{", "Source", ":", "client", ".", "Stream", "(", "logProject", ",", "log", ".", "Path", ")", ".", "Fetcher", "(", "c", ",", "nil", ")", ",", "Raw", ":", "true", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Unmarshal the source manifest from the bytes.", "var", "manifest", "srcman", ".", "Manifest", "\n", "if", "err", ":=", "proto", ".", "Unmarshal", "(", "buf", ".", "Bytes", "(", ")", ",", "&", "manifest", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "results", ":=", "make", "(", "Checkout", ")", "\n", "for", "dirname", ",", "dir", ":=", "range", "manifest", ".", "Directories", "{", "gitCheckout", ":=", "dir", ".", "GetGitCheckout", "(", ")", "\n", "if", "gitCheckout", "==", "nil", "{", "continue", "\n", "}", "\n\n", "url", ",", "err", ":=", "gitiles", ".", "NormalizeRepoURL", "(", "gitCheckout", ".", "RepoUrl", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "gitCheckout", ".", "RepoUrl", ",", "dirname", ")", "\n", "continue", "\n", "}", "\n\n", "if", "!", "strings", ".", "HasSuffix", "(", "url", ".", "Host", ",", "\"", "\"", ")", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "gitCheckout", ".", "RepoUrl", ",", "dirname", ")", "\n", "continue", "\n", "}", "\n", "results", "[", "url", ".", "String", "(", ")", "]", "=", "gitCheckout", ".", "Revision", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "srcmanCheckout", "is", "a", "CheckoutFunc", "which", "retrieves", "a", "source", "checkout", "related", "to", "a", "build", "by", "querying", "LogDog", "for", "a", "source", "manifest", "stream", "associated", "with", "that", "build", ".", "It", "assumes", "that", "the", "build", "has", "exactly", "one", "source", "manifest", "." ]

[ "func", "NewGoroutinePool", "(", "ctx", "context", ".", "Context", ",", "maxConcurrentJobs", "int", ")", "*", "GoroutinePool", "{", "return", "&", "GoroutinePool", "{", "ctx", ":", "ctx", ",", "sema", ":", "newSemaphore", "(", "maxConcurrentJobs", ")", ",", "}", "\n", "}" ]

[ "NewGoroutinePool", "creates", "a", "new", "GoroutinePool", "running", "at", "most", "maxConcurrentJobs", "concurrent", "operations", "." ]

[ "func", "(", "g", "*", "GoroutinePool", ")", "Schedule", "(", "job", ",", "onCanceled", "func", "(", ")", ")", "{", "g", ".", "wg", ".", "Add", "(", "1", ")", "\n", "// Note: We could save a bit of memory by preallocating maxConcurrentJobs", "// goroutines instead of one goroutine per item.", "go", "func", "(", ")", "{", "defer", "g", ".", "wg", ".", "Done", "(", ")", "\n", "if", "g", ".", "sema", ".", "wait", "(", "g", ".", "ctx", ")", "==", "nil", "{", "defer", "g", ".", "sema", ".", "signal", "(", ")", "\n", "job", "(", ")", "\n", "}", "else", "if", "onCanceled", "!=", "nil", "{", "onCanceled", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "Schedule", "adds", "a", "new", "job", "for", "execution", "as", "a", "separate", "goroutine", ".", "If", "the", "GoroutinePool", "context", "is", "canceled", "onCanceled", "is", "called", "instead", ".", "It", "is", "fine", "to", "pass", "nil", "as", "onCanceled", "." ]

[ "func", "NewGoroutinePriorityPool", "(", "ctx", "context", ".", "Context", ",", "maxConcurrentJobs", "int", ")", "*", "GoroutinePriorityPool", "{", "pool", ":=", "&", "GoroutinePriorityPool", "{", "ctx", ":", "ctx", ",", "sema", ":", "newSemaphore", "(", "maxConcurrentJobs", ")", ",", "tasks", ":", "priorityQueue", "{", "}", ",", "}", "\n", "return", "pool", "\n", "}" ]

[ "NewGoroutinePriorityPool", "creates", "a", "new", "goroutine", "pool", "with", "at", "most", "maxConcurrentJobs", ".", "Each", "task", "is", "run", "according", "to", "the", "priority", "of", "each", "item", "." ]

[ "func", "(", "g", "*", "GoroutinePriorityPool", ")", "Schedule", "(", "priority", "int64", ",", "job", ",", "onCanceled", "func", "(", ")", ")", "{", "g", ".", "wg", ".", "Add", "(", "1", ")", "\n", "t", ":=", "&", "task", "{", "priority", ",", "job", ",", "onCanceled", "}", "\n", "g", ".", "mu", ".", "Lock", "(", ")", "\n", "heap", ".", "Push", "(", "&", "g", ".", "tasks", ",", "t", ")", "\n", "g", ".", "mu", ".", "Unlock", "(", ")", "\n", "go", "g", ".", "executeOne", "(", ")", "\n", "}" ]

[ "Schedule", "adds", "a", "new", "job", "for", "execution", "as", "a", "separate", "goroutine", ".", "If", "the", "GoroutinePriorityPool", "is", "canceled", "onCanceled", "is", "called", "instead", ".", "It", "is", "fine", "to", "pass", "nil", "as", "onCanceled", ".", "Smaller", "values", "of", "priority", "imply", "earlier", "execution", ".", "The", "lower", "the", "priority", "value", "the", "higher", "the", "priority", "of", "the", "item", "." ]

[ "func", "NewMessage", "(", "typ", "*", "MessageType", ")", "*", "Message", "{", "return", "&", "Message", "{", "typ", ":", "typ", ",", "fields", ":", "starlark", ".", "StringDict", "{", "}", ",", "}", "\n", "}" ]

[ "NewMessage", "instantiates", "a", "new", "empty", "message", "of", "the", "given", "type", "." ]

[ "func", "(", "m", "*", "Message", ")", "ToProto", "(", ")", "(", "proto", ".", "Message", ",", "error", ")", "{", "ptr", ":=", "m", ".", "typ", ".", "NewProtoMessage", "(", ")", "// ~ ptr := &ProtoMessage{}", "\n", "msg", ":=", "ptr", ".", "Elem", "(", ")", "// ~ msg := *ptr (a reference)", "\n\n", "for", "name", ",", "val", ":=", "range", "m", ".", "fields", "{", "fd", ",", "ok", ":=", "m", ".", "typ", ".", "fields", "[", "name", "]", "\n", "if", "!", "ok", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "assign", "(", "fd", ".", "onProtoReflection", "(", "msg", ",", "reflectToProto", ")", ",", "val", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "m", ".", "Type", "(", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "ptr", ".", "Interface", "(", ")", ".", "(", "proto", ".", "Message", ")", ",", "nil", "\n", "}" ]

[ "ToProto", "returns", "a", "new", "populated", "proto", "message", "of", "an", "appropriate", "type", ".", "Returns", "an", "error", "if", "the", "data", "inside", "the", "Starlark", "representation", "of", "the", "message", "has", "a", "wrong", "type", "." ]

[ "func", "(", "m", "*", "Message", ")", "FromProto", "(", "p", "proto", ".", "Message", ")", "error", "{", "ptr", ":=", "reflect", ".", "ValueOf", "(", "p", ")", "\n", "if", "ptr", ".", "Type", "(", ")", "!=", "m", ".", "typ", ".", "Type", "(", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ptr", ".", "Type", "(", ")", ",", "m", ".", "typ", ".", "Type", "(", ")", ")", "\n", "}", "\n\n", "msg", ":=", "ptr", ".", "Elem", "(", ")", "\n", "for", "name", ",", "fd", ":=", "range", "m", ".", "typ", ".", "fields", "{", "// Get the field's value from the proto message as reflect.Value. For unused", "// oneof alternatives this is an invalid zero value, we skip them right", "// away. For other fields it is reflect.Value (of fd.typ type) that MAY be", "// nil inside (for unset fields). toStarlarkValue converts such values to", "// starlark.None.", "val", ":=", "fd", ".", "onProtoReflection", "(", "msg", ",", "reflectFromProto", ")", "\n", "if", "!", "val", ".", "IsValid", "(", ")", "{", "continue", "\n", "}", "\n", "// Convert the Go value to the corresponding Starlark value and assign it to", "// the field in 'm'.", "sv", ",", "err", ":=", "toStarlarkValue", "(", "val", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "m", ".", "SetField", "(", "name", ",", "sv", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "FromProto", "populates", "fields", "of", "this", "message", "based", "on", "values", "in", "proto", ".", "Message", ".", "Returns", "an", "error", "on", "type", "mismatch", "." ]

[ "func", "(", "m", "*", "Message", ")", "String", "(", ")", "string", "{", "msg", ",", "err", ":=", "m", ".", "ToProto", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "m", ".", "Type", "(", ")", ",", "err", ")", "\n", "}", "\n", "return", "msg", ".", "String", "(", ")", "\n", "}" ]

[ "Basic", "starlark", ".", "Value", "interface", ".", "String", "implements", "starlark", ".", "Value", "." ]

[ "func", "(", "m", "*", "Message", ")", "Freeze", "(", ")", "{", "if", "!", "m", ".", "frozen", "{", "m", ".", "fields", ".", "Freeze", "(", ")", "\n", "m", ".", "frozen", "=", "true", "\n", "}", "\n", "}" ]

[ "Freeze", "implements", "starlark", ".", "Value", "." ]

[ "func", "(", "m", "*", "Message", ")", "Attr", "(", "name", "string", ")", "(", "starlark", ".", "Value", ",", "error", ")", "{", "// The field was already set?", "val", ",", "ok", ":=", "m", ".", "fields", "[", "name", "]", "\n", "if", "ok", "{", "return", "val", ",", "nil", "\n", "}", "\n\n", "// The field wasn't set, but it is defined by the proto schema? Need to", "// generate and return the default value then, except for oneof alternatives", "// that do not have defaults. This is needed to make sure callers are", "// explicitly picking a oneof alternative by assigning a value to it, rather", "// than have it picked implicitly be reading an attribute (which is weird).", "if", "fd", ",", "ok", ":=", "m", ".", "typ", ".", "fields", "[", "name", "]", ";", "ok", "{", "if", "!", "fd", ".", "defaultable", "{", "return", "starlark", ".", "None", ",", "nil", "\n", "}", "\n", "def", ",", "err", ":=", "newDefaultValue", "(", "fd", ".", "typ", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Lazy initialization of fields is an implementation detail. From the", "// caller's point of view, all fields had their default values even before", "// the object was frozen. Lazy-initialize the field, even if we are frozen,", "// but make sure it is frozen itself too.", "//", "// TODO(vadimsh): This is not thread safe and should be improved if a frozen", "// *Message is shared between goroutines. Generally frozen values are", "// assumed to be safe for cross-goroutine use, which is not the case here.", "// If this becomes important, we can force-initialize and freeze all default", "// fields in Freeze().", "if", "m", ".", "frozen", "{", "def", ".", "Freeze", "(", ")", "\n", "}", "\n", "m", ".", "fields", "[", "name", "]", "=", "def", "\n", "return", "def", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "m", ".", "Type", "(", ")", ",", "name", ")", "\n", "}" ]

[ "HasAttrs", "and", "HasSetField", "interfaces", "that", "make", "the", "message", "look", "like", "a", "struct", ".", "Attr", "implements", "starlark", ".", "HasAttrs", "." ]

[ "func", "(", "m", "*", "Message", ")", "SetField", "(", "name", "string", ",", "val", "starlark", ".", "Value", ")", "error", "{", "fd", ",", "ok", ":=", "m", ".", "typ", ".", "fields", "[", "name", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "m", ".", "Type", "(", ")", ",", "name", ")", "\n", "}", "\n\n", "// Setting a field to None removes it completely.", "if", "val", "==", "starlark", ".", "None", "{", "if", "err", ":=", "m", ".", "checkMutable", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "delete", "(", "m", ".", "fields", ",", "name", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// If assigning to a messaged-valued field (singular or repeated), recognize", "// dicts and Nones and use them to instantiate values (perhaps empty) of the", "// corresponding proto type. This allows to construct deeply nested protobuf", "// messages just by using lists, dicts and primitive values. Python does this", "// too.", "val", ",", "err", ":=", "maybeMakeMessages", "(", "fd", ".", "typ", ",", "val", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "m", ".", "Type", "(", ")", ",", "err", ")", "\n", "}", "\n\n", "// Do a light type check. It doesn't \"recurse\" into lists or tuples. So it is", "// still possible to assign e.g. a list of strings to a \"repeated int64\"", "// field. This will be discovered later in ToProto when trying to construct", "// a proto message from Starlark values.", "if", "err", ":=", "checkAssignable", "(", "fd", ".", "typ", ",", "val", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ".", "Type", "(", ")", ",", "name", ",", "m", ".", "Type", "(", ")", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "m", ".", "checkMutable", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "m", ".", "fields", "[", "name", "]", "=", "val", "\n\n", "// onChanged hooks is used by oneof's to clear alternatives that weren't", "// picked.", "if", "fd", ".", "onChanged", "!=", "nil", "{", "fd", ".", "onChanged", "(", "m", ".", "fields", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "SetField", "implements", "starlark", ".", "HasSetField", "." ]

[ "func", "(", "m", "*", "Message", ")", "checkMutable", "(", ")", "error", "{", "if", "m", ".", "frozen", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "m", ".", "Type", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "checkMutable", "returns", "an", "error", "if", "the", "message", "is", "frozen", "." ]

[ "func", "shouldMakeMessages", "(", "seq", "starlark", ".", "Sequence", ")", "bool", "{", "iter", ":=", "seq", ".", "Iterate", "(", ")", "\n", "defer", "iter", ".", "Done", "(", ")", "\n", "var", "v", "starlark", ".", "Value", "\n", "for", "iter", ".", "Next", "(", "&", "v", ")", "{", "if", "v", "==", "starlark", ".", "None", "{", "return", "true", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "v", ".", "(", "*", "starlark", ".", "Dict", ")", ";", "ok", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "shouldMakeMessages", "returns", "true", "if", "seq", "has", "at", "least", "one", "dict", "or", "None", "that", "should", "be", "converted", "to", "a", "proto", "message", "." ]

[ "func", "(", "s", "*", "Service", ")", "Run", "(", "c", "context", ".", "Context", ",", "f", "func", "(", "context", ".", "Context", ")", "error", ")", "{", "// Log to Stdout using JSON log lines.", "c", "=", "teelogger", ".", "Use", "(", "c", ",", "gkelogger", ".", "GetFactory", "(", "os", ".", "Stdout", ")", ")", "\n\n", "// If a service name isn't specified, default to the base of the current", "// executable.", "if", "s", ".", "Name", "==", "\"", "\"", "{", "s", ".", "Name", "=", "filepath", ".", "Base", "(", "os", ".", "Args", "[", "0", "]", ")", "\n", "}", "\n", "s", ".", "useDatastoreConfig", "=", "true", "// If available, use datastore config.", "\n\n", "rc", ":=", "0", "\n", "if", "err", ":=", "s", ".", "runImpl", "(", "c", ",", "f", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "rc", "=", "1", "\n", "}", "\n", "os", ".", "Exit", "(", "rc", ")", "\n", "}" ]

[ "Run", "performs", "service", "-", "wide", "initialization", "and", "invokes", "the", "specified", "run", "function", "." ]

[ "func", "(", "s", "*", "Service", ")", "probeGCEEnvironment", "(", "c", "context", ".", "Context", ")", "{", "s", ".", "onGCE", "=", "metadata", ".", "OnGCE", "(", ")", "\n", "if", "!", "s", ".", "onGCE", "{", "log", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "// Determine our service ID from metadata. The service ID will equal the cloud", "// project ID.", "if", "s", ".", "serviceID", "==", "\"", "\"", "{", "var", "err", "error", "\n", "if", "s", ".", "serviceID", ",", "err", "=", "metadata", ".", "ProjectID", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n\n", "log", ".", "Fields", "{", "\"", "\"", ":", "s", ".", "serviceID", ",", "}", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "probeGCEEnvironment", "fills", "in", "any", "parameters", "that", "can", "be", "probed", "from", "Google", "Compute", "Engine", "metadata", ".", "If", "we", "re", "not", "running", "on", "GCE", "this", "will", "do", "nothing", ".", "It", "is", "non", "-", "fatal", "if", "any", "given", "GCE", "field", "fails", "to", "be", "probed", "." ]

[ "func", "(", "s", "*", "Service", ")", "ServiceConfigPath", "(", ")", "(", "cfglib", ".", "Set", ",", "string", ")", "{", "return", "cfglib", ".", "ServiceSet", "(", "s", ".", "serviceID", ")", ",", "svcconfig", ".", "ServiceConfigPath", "\n", "}" ]

[ "ServiceConfigPath", "returns", "the", "ConfigSet", "and", "path", "to", "the", "current", "service", "s", "configuration", "." ]

[ "func", "(", "s", "*", "Service", ")", "ProjectConfigPath", "(", "proj", "types", ".", "ProjectName", ")", "(", "cfglib", ".", "Set", ",", "string", ")", "{", "return", "cfglib", ".", "ProjectSet", "(", "string", "(", "proj", ")", ")", ",", "svcconfig", ".", "ProjectConfigPath", "(", "s", ".", "serviceID", ")", "\n", "}" ]

[ "ProjectConfigPath", "returns", "the", "ConfigSet", "and", "path", "to", "the", "current", "service", "s", "project", "configuration", "for", "proj", "." ]

[ "func", "(", "s", "*", "Service", ")", "ProjectConfig", "(", "c", "context", ".", "Context", ",", "proj", "types", ".", "ProjectName", ")", "(", "*", "svcconfig", ".", "ProjectConfig", ",", "error", ")", "{", "cset", ",", "path", ":=", "s", ".", "ProjectConfigPath", "(", "proj", ")", "\n\n", "var", "pcfg", "svcconfig", ".", "ProjectConfig", "\n", "msg", ",", "err", ":=", "s", ".", "configCache", ".", "Get", "(", "c", ",", "cset", ",", "path", ",", "&", "pcfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "cset", ",", "path", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "msg", ".", "(", "*", "svcconfig", ".", "ProjectConfig", ")", ",", "nil", "\n", "}" ]

[ "ProjectConfig", "returns", "the", "current", "service", "s", "project", "configuration", "for", "proj", "." ]

[ "func", "(", "s", "*", "Service", ")", "GSClient", "(", "c", "context", ".", "Context", ",", "proj", "types", ".", "ProjectName", ")", "(", "gs", ".", "Client", ",", "error", ")", "{", "// Get an Authenticator bound to the token scopes that we need for", "// authenticated Cloud Storage access.", "transport", ",", "err", ":=", "serverAuth", ".", "GetRPCTransport", "(", "c", ",", "serverAuth", ".", "AsProject", ",", "serverAuth", ".", "WithProject", "(", "string", "(", "proj", ")", ")", ",", "serverAuth", ".", "WithScopes", "(", "gs", ".", "ReadWriteScopes", "...", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "client", ",", "err", ":=", "gs", ".", "NewProdClient", "(", "c", ",", "transport", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "client", ",", "nil", "\n", "}" ]

[ "GSClient", "returns", "an", "authenticated", "Google", "Storage", "client", "instance", "." ]

[ "func", "(", "s", "*", "Service", ")", "withAuthService", "(", "c", "context", ".", "Context", ")", "context", ".", "Context", "{", "return", "serverAuth", ".", "Initialize", "(", "c", ",", "&", "serverAuth", ".", "Config", "{", "DBProvider", ":", "nil", ",", "// We don't need to store an auth DB.", "Signer", ":", "nil", ",", "// We don't need to sign anything.", "AccessTokenProvider", ":", "func", "(", "ic", "context", ".", "Context", ",", "scopes", "[", "]", "string", ")", "(", "*", "oauth2", ".", "Token", ",", "error", ")", "{", "// Create a new Authenticator for the supplied scopes.", "//", "// Pass our outer Context, since we don't want the cached Authenticator", "// instance to be permanently bound to the inner Context.", "a", ",", "err", ":=", "s", ".", "authenticatorForScopes", "(", "c", ",", "scopes", ")", "\n", "scopesStr", ":=", "strings", ".", "Join", "(", "scopes", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fields", "{", "\"", "\"", ":", "scopesStr", ",", "log", ".", "ErrorKey", ":", "err", ",", "}", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "tok", ",", "err", ":=", "a", ".", "GetAccessToken", "(", "minAuthTokenLifetime", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fields", "{", "\"", "\"", ":", "scopesStr", ",", "log", ".", "ErrorKey", ":", "err", ",", "}", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "tok", ",", "err", "\n", "}", ",", "AnonymousTransport", ":", "func", "(", "ic", "context", ".", "Context", ")", "http", ".", "RoundTripper", "{", "return", "s", ".", "unauthenticatedTransport", "(", ")", "\n", "}", ",", "}", ")", "\n", "}" ]

[ "withAuthService", "configures", "service", "-", "wide", "authentication", "and", "installs", "it", "into", "the", "supplied", "Context", "." ]

[ "func", "(", "p", "*", "Profiler", ")", "AddFlags", "(", "fs", "*", "flag", ".", "FlagSet", ")", "{", "fs", ".", "StringVar", "(", "&", "p", ".", "BindHTTP", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "fs", ".", "StringVar", "(", "&", "p", ".", "Dir", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "fs", ".", "BoolVar", "(", "&", "p", ".", "ProfileCPU", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "fs", ".", "BoolVar", "(", "&", "p", ".", "ProfileHeap", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n\n", "}" ]

[ "AddFlags", "adds", "command", "line", "flags", "to", "common", "Profiler", "fields", "." ]

[ "func", "(", "p", "*", "Profiler", ")", "Start", "(", ")", "error", "{", "if", "p", ".", "Dir", "==", "\"", "\"", "{", "if", "p", ".", "ProfileCPU", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "p", ".", "ProfileHeap", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "if", "p", ".", "ProfileCPU", "{", "out", ",", "err", ":=", "os", ".", "Create", "(", "p", ".", "generateOutPath", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "pprof", ".", "StartCPUProfile", "(", "out", ")", "\n", "p", ".", "profilingCPU", "=", "true", "\n", "}", "\n\n", "if", "p", ".", "BindHTTP", "!=", "\"", "\"", "{", "if", "err", ":=", "p", ".", "startHTTP", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Start", "starts", "the", "Profiler", "s", "configured", "operations", ".", "On", "success", "returns", "a", "function", "that", "can", "be", "called", "to", "shutdown", "the", "profiling", "server", ".", "Calling", "Stop", "is", "not", "necessary", "but", "will", "enable", "end", "-", "of", "-", "operation", "profiling", "to", "be", "gathered", "." ]

[ "func", "(", "p", "*", "Profiler", ")", "Stop", "(", ")", "{", "if", "p", ".", "profilingCPU", "{", "pprof", ".", "StopCPUProfile", "(", ")", "\n", "p", ".", "profilingCPU", "=", "false", "\n", "}", "\n\n", "if", "p", ".", "listener", "!=", "nil", "{", "if", "err", ":=", "p", ".", "listener", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "p", ".", "getLogger", "(", ")", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "p", ".", "listener", "=", "nil", "\n", "}", "\n\n", "// Take one final snapshot.", "p", ".", "DumpSnapshot", "(", ")", "\n", "}" ]

[ "Stop", "stops", "the", "Profiler", "s", "operations", "." ]

[ "func", "(", "p", "*", "Profiler", ")", "DumpSnapshot", "(", ")", "error", "{", "if", "p", ".", "Dir", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "if", "p", ".", "ProfileHeap", "{", "if", "err", ":=", "p", ".", "dumpHeapProfile", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "DumpSnapshot", "dumps", "a", "profile", "snapshot", "to", "the", "configured", "output", "directory", ".", "If", "no", "output", "directory", "is", "configured", "nothing", "will", "happen", "." ]

[ "func", "ServiceVersion", "(", "c", "context", ".", "Context", ",", "s", "signing", ".", "Signer", ")", "(", "string", ",", "error", ")", "{", "inf", ",", "err", ":=", "s", ".", "ServiceInfo", "(", "c", ")", "// cached", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "inf", ".", "AppID", ",", "inf", ".", "AppVersion", ")", ",", "nil", "\n", "}" ]

[ "ServiceVersion", "returns", "a", "string", "that", "identifies", "the", "app", "and", "the", "version", ".", "It", "is", "put", "in", "some", "server", "responses", ".", "The", "function", "extracts", "this", "information", "from", "the", "given", "signer", ".", "This", "function", "almost", "never", "returns", "errors", ".", "It", "can", "return", "an", "error", "only", "when", "called", "for", "the", "first", "time", "during", "the", "process", "lifetime", ".", "It", "gets", "cached", "after", "first", "successful", "return", "." ]

[ "func", "(", "r", "*", "GetOAuthTokenRequest", ")", "Validate", "(", ")", "error", "{", "switch", "{", "case", "len", "(", "r", ".", "Scopes", ")", "==", "0", ":", "return", "errors", ".", "New", "(", "`field \"scopes\" is required`", ")", "\n", "case", "len", "(", "r", ".", "Secret", ")", "==", "0", ":", "return", "errors", ".", "New", "(", "`field \"secret\" is required`", ")", "\n", "case", "r", ".", "AccountID", "==", "\"", "\"", ":", "return", "errors", ".", "New", "(", "`field \"account_id\" is required`", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "checks", "that", "the", "request", "is", "structurally", "valid", "." ]

[ "func", "(", "pm", "*", "Map", ")", "Get", "(", "c", "context", ".", "Context", ",", "key", "interface", "{", "}", ",", "gen", "Generator", ")", "*", "Promise", "{", "pm", ".", "mu", ".", "RLock", "(", ")", "\n", "p", ":=", "pm", ".", "m", "[", "key", "]", "\n", "pm", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "if", "p", "!=", "nil", "{", "return", "p", "\n", "}", "\n\n", "pm", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "pm", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "p", "=", "pm", ".", "m", "[", "key", "]", ";", "p", "==", "nil", "{", "p", "=", "New", "(", "c", ",", "gen", ")", "\n", "if", "pm", ".", "m", "==", "nil", "{", "pm", ".", "m", "=", "make", "(", "map", "[", "interface", "{", "}", "]", "*", "Promise", ",", "1", ")", "\n", "}", "\n", "pm", ".", "m", "[", "key", "]", "=", "p", "\n", "}", "\n", "return", "p", "\n", "}" ]

[ "Get", "either", "returns", "an", "existing", "promise", "for", "the", "given", "key", "or", "creates", "and", "immediately", "launches", "a", "new", "promise", "." ]

[ "func", "MakeBuildBugLink", "(", "bt", "*", "config", ".", "BugTemplate", ",", "data", "interface", "{", "}", ")", "(", "string", ",", "error", ")", "{", "summary", ",", "err", ":=", "summary", "(", "bt", ",", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "description", ",", "err", ":=", "description", "(", "bt", ",", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "query", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "summary", "}", ",", "\"", "\"", ":", "{", "description", "}", ",", "}", "\n\n", "if", "len", "(", "bt", ".", "Components", ")", ">", "0", "{", "query", ".", "Add", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "bt", ".", "Components", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "link", ":=", "url", ".", "URL", "{", "Scheme", ":", "\"", "\"", ",", "Host", ":", "\"", "\"", ",", "Path", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "bt", ".", "MonorailProject", ")", ",", "RawQuery", ":", "query", ".", "Encode", "(", ")", ",", "}", "\n\n", "return", "link", ".", "String", "(", ")", ",", "nil", "\n", "}" ]

[ "makeBuildBugLink", "attempts", "to", "create", "the", "feedback", "link", "for", "the", "build", "page", ".", "If", "the", "project", "is", "not", "configured", "for", "a", "custom", "build", "bug", "link", "or", "an", "interpolation", "placeholder", "cannot", "be", "satisfied", "an", "empty", "string", "is", "returned", "." ]

[ "func", "(", "cache", "*", "Cache", ")", "pruneInterval", "(", ")", "time", ".", "Duration", "{", "if", "cache", ".", "AccessUpdateInterval", ">", "0", "&&", "cache", ".", "PruneFactor", ">", "0", "{", "return", "cache", ".", "AccessUpdateInterval", "*", "time", ".", "Duration", "(", "1", "+", "cache", ".", "PruneFactor", ")", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "pruneInterval", "calculates", "the", "prune", "interval", ".", "This", "is", "a", "function", "of", "the", "cache", "s", "AccessUpdateInterval", "and", "PruneFactor", ".", "If", "either", "AccessUpdateInterval", "or", "PruneFactor", "is", "<", "=", "0", "this", "will", "return", "0", "indicating", "no", "prune", "interval", "." ]