Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "(", "LinuxStrategy", ")", "configureAutoMount", "(", "ctx", "context", ".", "Context", ",", "disk", "string", ")", "error", "{", "// Wait for the disk to be attached.", "for", "{", "err", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "disk", ")", ".", "Run", "(", ")", "\n", "if", "err", "==", "nil", "{", "logging", ".", "Infof", "(", "ctx", ",", "\"", "\"", ",", "disk", ")", "\n", "break", "\n", "}", "\n", "s", ":=", "err", ".", "(", "*", "exec", ".", "ExitError", ")", ".", "Sys", "(", ")", ".", "(", "syscall", ".", "WaitStatus", ")", "\n", "if", "s", ".", "ExitStatus", "(", ")", "!=", "2", "{", "// 2 means the specified device wasn't found.", "// Keep waiting if 2, otherwise return an error.", "return", "err", "\n", "}", "\n", "time", ".", "Sleep", "(", "60", "*", "time", ".", "Second", ")", "\n", "logging", ".", "Infof", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "\n", "// Configure auto-mount using fstab.", "f", ",", "err", ":=", "os", ".", "OpenFile", "(", "\"", "\"", ",", "os", ".", "O_RDWR", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "f", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "if", "strings", ".", "Contains", "(", "scanner", ".", "Text", "(", ")", ",", "disk", ")", "{", "logging", ".", "Infof", "(", "ctx", ",", "\"", "\"", ",", "disk", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "logging", ".", "Infof", "(", "ctx", ",", "\"", "\"", ",", "disk", ")", "\n", "// Ensure the cursor is at the end so the new line is appended.", "f", ".", "Seek", "(", "0", ",", "io", ".", "SeekEnd", ")", "\n", "line", ":=", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "disk", ")", ")", "\n", "if", "_", ",", "err", ":=", "f", ".", "Write", "(", "line", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// Ensure the file is closed before mount reads from it.", "f", ".", "Close", "(", ")", "\n", "return", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Run", "(", ")", "\n", "}" ]

[ "configureAutoMount", "mounts", "the", "specified", "disk", "and", "configures", "mount", "on", "startup", ".", "Assumes", "the", "disk", "is", "already", "formatted", "as", "ext4", "." ]

[ "func", "(", "SystemdStrategy", ")", "enableSwarming", "(", "ctx", "context", ".", "Context", ")", "error", "{", "if", "err", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", ".", "Run", "(", ")", "\n", "}" ]

[ "enableSwarming", "enables", "installed", "service", "." ]

[ "func", "getAgent", "(", "ctx", "context", ".", "Context", ")", "(", "*", "Agent", ",", "error", ")", "{", "if", "systemdFound", "(", ")", "{", "agent", ":=", "Agent", "{", "agentAutoStartPath", ":", "\"", "\"", ",", "agentAutoStartTemplate", ":", "\"", "\"", ",", "logsDir", ":", "\"", "\"", ",", "swarmingAutoStartPath", ":", "\"", "\"", ",", "swarmingAutoStartTemplate", ":", "\"", "\"", ",", "swarmingBotDir", ":", "\"", "\"", ",", "strategy", ":", "SystemdStrategy", "{", "}", ",", "}", "\n", "logging", ".", "Infof", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "&", "agent", ",", "nil", "\n", "}", "\n\n", "if", "upstartFound", "(", ")", "{", "agent", ":=", "Agent", "{", "agentAutoStartPath", ":", "\"", "\"", ",", "agentAutoStartTemplate", ":", "\"", "\"", ",", "logsDir", ":", "\"", "\"", ",", "swarmingAutoStartPath", ":", "\"", "\"", ",", "swarmingAutoStartTemplate", ":", "\"", "\"", ",", "swarmingBotDir", ":", "\"", "\"", ",", "strategy", ":", "UpstartStrategy", "{", "}", ",", "}", "\n", "logging", ".", "Infof", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "&", "agent", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "getAgent", "returns", "an", "agent", "which", "runs", "on", "Linux", "depending", "on", "supported", "init", "systems", "." ]

[ "func", "withConfig", "(", "c", "context", ".", "Context", ",", "cfg", "config", ".", "ConfigurationServer", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "c", ",", "&", "cfgKey", ",", "cfg", ")", "\n", "}" ]

[ "withConfig", "returns", "a", "new", "context", "with", "the", "given", "config", ".", "ConfigurationServer", "installed", "." ]

[ "func", "getConfig", "(", "c", "context", ".", "Context", ")", "config", ".", "ConfigurationServer", "{", "return", "c", ".", "Value", "(", "&", "cfgKey", ")", ".", "(", "config", ".", "ConfigurationServer", ")", "\n", "}" ]

[ "getConfig", "returns", "the", "config", ".", "ConfigurationServer", "installed", "in", "the", "current", "context", "." ]

[ "func", "New", "(", "err", "error", ")", "config", ".", "Interface", "{", "if", "err", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "erroringInterface", "{", "err", "}", "\n", "}" ]

[ "New", "creates", "a", "new", "erroring", "interface", ".", "This", "interface", "will", "always", "return", "an", "error", "for", "every", "API", "call", ".", "The", "supplied", "error", "must", "not", "be", "nil", ".", "If", "it", "is", "New", "will", "panic", "." ]

[ "func", "GetPublicStateKind", "(", "j", "*", "engine", ".", "Job", ",", "traits", "task", ".", "Traits", ")", "PublicStateKind", "{", "// TODO(vadimsh): Expose more states.", "cronTick", ":=", "j", ".", "CronTickTime", "(", ")", "\n", "switch", "{", "case", "len", "(", "j", ".", "ActiveInvocations", ")", "!=", "0", ":", "return", "PublicStateRunning", "\n", "case", "!", "j", ".", "Enabled", ":", "return", "PublicStateDisabled", "\n", "case", "j", ".", "Paused", ":", "return", "PublicStatePaused", "\n", "case", "!", "cronTick", ".", "IsZero", "(", ")", "&&", "cronTick", "!=", "schedule", ".", "DistantFuture", ":", "return", "PublicStateScheduled", "\n", "default", ":", "return", "PublicStateWaiting", "\n", "}", "\n", "}" ]

[ "GetPublicStateKind", "returns", "user", "-", "friendly", "state", "for", "a", "job", "." ]

[ "func", "GetJobTraits", "(", "ctx", "context", ".", "Context", ",", "cat", "catalog", ".", "Catalog", ",", "j", "*", "engine", ".", "Job", ")", "(", "task", ".", "Traits", ",", "error", ")", "{", "taskDef", ",", "err", ":=", "cat", ".", "UnmarshalTask", "(", "ctx", ",", "j", ".", "Task", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "ctx", ",", "\"", "\"", ",", "j", ".", "JobID", ")", "\n", "return", "task", ".", "Traits", "{", "}", ",", "err", "\n", "}", "\n", "if", "manager", ":=", "cat", ".", "GetTaskManager", "(", "taskDef", ")", ";", "manager", "!=", "nil", "{", "return", "manager", ".", "Traits", "(", ")", ",", "nil", "\n", "}", "\n", "return", "task", ".", "Traits", "{", "}", ",", "nil", "\n", "}" ]

[ "GetJobTraits", "asks", "the", "corresponding", "task", "manager", "for", "a", "traits", "struct", "." ]

[ "func", "(", "f", "*", "ResolvedFile", ")", "Serialize", "(", "w", "io", ".", "Writer", ")", "error", "{", "// piggyback on top of File.Serialize.", "packagesBySubdir", ":=", "make", "(", "map", "[", "string", "]", "PackageSlice", ",", "len", "(", "f", ".", "PackagesBySubdir", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "f", ".", "PackagesBySubdir", "{", "slc", ":=", "make", "(", "PackageSlice", ",", "len", "(", "v", ")", ")", "\n", "for", "i", ",", "pkg", ":=", "range", "v", "{", "slc", "[", "i", "]", "=", "PackageDef", "{", "PackageTemplate", ":", "pkg", ".", "PackageName", ",", "UnresolvedVersion", ":", "pkg", ".", "InstanceID", ",", "}", "\n", "}", "\n", "packagesBySubdir", "[", "k", "]", "=", "slc", "\n", "}", "\n", "return", "(", "&", "File", "{", "ServiceURL", ":", "f", ".", "ServiceURL", ",", "ParanoidMode", ":", "f", ".", "ParanoidMode", ",", "PackagesBySubdir", ":", "packagesBySubdir", ",", "}", ")", ".", "Serialize", "(", "w", ")", "\n", "}" ]

[ "Serialize", "writes", "the", "ResolvedFile", "to", "an", "io", ".", "Writer", "in", "canonical", "order", "." ]

[ "func", "(", "f", "*", "File", ")", "Serialize", "(", "w", "io", ".", "Writer", ")", "error", "{", "_", ",", "err", ":=", "iotools", ".", "WriteTracker", "(", "w", ",", "func", "(", "w", "io", ".", "Writer", ")", "error", "{", "needsNLs", ":=", "0", "\n", "maybeAddNL", ":=", "func", "(", ")", "{", "if", "needsNLs", ">", "0", "{", "w", ".", "Write", "(", "bytes", ".", "Repeat", "(", "[", "]", "byte", "(", "\"", "\\n", "\"", ")", ",", "needsNLs", ")", ")", "\n", "needsNLs", "=", "0", "\n", "}", "\n", "}", "\n\n", "if", "f", ".", "ServiceURL", "!=", "\"", "\"", "{", "maybeAddNL", "(", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\"", ",", "f", ".", "ServiceURL", ")", "\n", "needsNLs", "=", "1", "\n", "}", "\n", "if", "f", ".", "ParanoidMode", "!=", "\"", "\"", "&&", "f", ".", "ParanoidMode", "!=", "deployer", ".", "NotParanoid", "{", "maybeAddNL", "(", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\"", ",", "f", ".", "ParanoidMode", ")", "\n", "needsNLs", "=", "1", "\n", "}", "\n", "if", "f", ".", "ResolvedVersions", "!=", "\"", "\"", "{", "maybeAddNL", "(", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\"", ",", "f", ".", "ResolvedVersions", ")", "\n", "needsNLs", "=", "1", "\n", "}", "\n\n", "if", "needsNLs", "!=", "0", "{", "needsNLs", "+=", "1", "// new line separator if any of $Directives were used", "\n", "}", "\n\n", "if", "len", "(", "f", ".", "VerifyPlatforms", ")", ">", "0", "{", "for", "_", ",", "plat", ":=", "range", "f", ".", "VerifyPlatforms", "{", "maybeAddNL", "(", ")", "\n\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\"", ",", "plat", ".", "String", "(", ")", ")", "\n", "needsNLs", "=", "1", "\n", "}", "\n\n", "needsNLs", "=", "2", "\n", "}", "\n\n", "keys", ":=", "make", "(", "sort", ".", "StringSlice", ",", "0", ",", "len", "(", "f", ".", "PackagesBySubdir", ")", ")", "\n", "for", "k", ":=", "range", "f", ".", "PackagesBySubdir", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "keys", ".", "Sort", "(", ")", "\n\n", "for", "_", ",", "k", ":=", "range", "keys", "{", "maybeAddNL", "(", ")", "\n", "if", "k", "!=", "\"", "\"", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\"", ",", "k", ")", "\n", "needsNLs", "=", "1", "\n", "}", "\n\n", "pkgs", ":=", "f", ".", "PackagesBySubdir", "[", "k", "]", "\n", "pkgsSort", ":=", "make", "(", "PackageSlice", ",", "len", "(", "pkgs", ")", ")", "\n", "maxLength", ":=", "0", "\n", "for", "i", ",", "pkg", ":=", "range", "pkgs", "{", "pkgsSort", "[", "i", "]", "=", "pkg", "\n", "if", "l", ":=", "len", "(", "pkg", ".", "PackageTemplate", ")", ";", "l", ">", "maxLength", "{", "maxLength", "=", "l", "\n", "}", "\n", "}", "\n", "sort", ".", "Sort", "(", "pkgsSort", ")", "\n\n", "for", "_", ",", "p", ":=", "range", "pkgsSort", "{", "maybeAddNL", "(", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\"", ",", "maxLength", "+", "1", ",", "p", ".", "PackageTemplate", ",", "p", ".", "UnresolvedVersion", ")", "\n", "needsNLs", "=", "1", "\n", "}", "\n", "needsNLs", "++", "\n", "}", "\n\n", "// We only ever want to end the file with 1 newline.", "if", "needsNLs", ">", "0", "{", "needsNLs", "=", "1", "\n", "}", "\n", "maybeAddNL", "(", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "Serialize", "writes", "the", "File", "to", "an", "io", ".", "Writer", "in", "canonical", "order", "." ]

[ "func", "WithRequestCache", "(", "c", "context", ".", "Context", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "c", ",", "&", "requestCacheKey", ",", "lru", ".", "New", "(", "0", ")", ")", "\n", "}" ]

[ "WithRequestCache", "initializes", "context", "-", "bound", "local", "cache", "and", "adds", "it", "to", "the", "Context", ".", "The", "cache", "has", "unbounded", "size", ".", "This", "is", "fine", "since", "the", "lifetime", "of", "the", "cache", "is", "still", "scoped", "to", "a", "single", "request", ".", "It", "can", "be", "used", "as", "a", "second", "fast", "layer", "of", "caching", "in", "front", "of", "memcache", ".", "It", "is", "never", "trimmed", "only", "released", "at", "once", "upon", "the", "request", "completion", "." ]

[ "func", "RequestCache", "(", "c", "context", ".", "Context", ")", "*", "lru", ".", "Cache", "{", "rc", ",", "_", ":=", "c", ".", "Value", "(", "&", "requestCacheKey", ")", ".", "(", "*", "lru", ".", "Cache", ")", "\n", "if", "rc", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "rc", "\n", "}" ]

[ "RequestCache", "retrieves", "a", "per", "-", "request", "in", "-", "memory", "cache", "of", "the", "Context", ".", "If", "no", "request", "cache", "is", "installed", "this", "will", "panic", "." ]

[ "func", "Backend", "(", "b", "backend", ".", "B", ",", "exp", "time", ".", "Duration", ")", "backend", ".", "B", "{", "return", "&", "caching", ".", "Backend", "{", "B", ":", "b", ",", "CacheGet", ":", "func", "(", "c", "context", ".", "Context", ",", "key", "caching", ".", "Key", ",", "l", "caching", ".", "Loader", ")", "(", "*", "caching", ".", "Value", ",", "error", ")", "{", "if", "key", ".", "Authority", "!=", "backend", ".", "AsService", "{", "return", "l", "(", "c", ",", "key", ",", "nil", ")", "\n", "}", "\n\n", "// Is the item already cached?", "k", ":=", "memcacheKey", "(", "&", "key", ")", "\n", "mci", ",", "err", ":=", "mc", ".", "GetKey", "(", "c", ",", "k", ")", "\n", "switch", "err", "{", "case", "nil", ":", "// Value was cached, successfully retrieved.", "v", ",", "err", ":=", "caching", ".", "DecodeValue", "(", "mci", ".", "Value", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "k", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "v", ",", "nil", "\n\n", "case", "mc", ".", "ErrCacheMiss", ":", "// Value was not cached. Load from Loader and cache.", "v", ",", "err", ":=", "l", "(", "c", ",", "key", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Attempt to cache the value. If this fails, we'll log a warning and", "// move on.", "err", "=", "func", "(", ")", "error", "{", "d", ",", "err", ":=", "v", ".", "Encode", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "if", "len", "(", "d", ")", ">", "maxMemCacheSize", "{", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "len", "(", "d", ")", ",", "maxMemCacheSize", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "item", ":=", "mc", ".", "NewItem", "(", "c", ",", "k", ")", ".", "SetValue", "(", "d", ")", ".", "SetExpiration", "(", "exp", ")", "\n", "if", "err", ":=", "mc", ".", "Set", "(", "c", ",", "item", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fields", "{", "log", ".", "ErrorKey", ":", "err", ",", "\"", "\"", ":", "k", ",", "}", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Return the loaded value.", "return", "v", ",", "nil", "\n\n", "default", ":", "// Unknown memcache error.", "log", ".", "Fields", "{", "log", ".", "ErrorKey", ":", "err", ",", "\"", "\"", ":", "k", ",", "}", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "l", "(", "c", ",", "key", ",", "nil", ")", "\n", "}", "\n", "}", ",", "}", "\n", "}" ]

[ "Backend", "wraps", "a", "backend", ".", "B", "instance", "with", "a", "memcache", "-", "backed", "caching", "layer", "whose", "entries", "expire", "after", "exp", "." ]

[ "func", "(", "v", "ValueType", ")", "IsCumulative", "(", ")", "bool", "{", "return", "v", "==", "CumulativeIntType", "||", "v", "==", "CumulativeFloatType", "||", "v", "==", "CumulativeDistributionType", "\n", "}" ]

[ "IsCumulative", "returns", "true", "if", "this", "is", "a", "cumulative", "metric", "value", "type", "." ]

[ "func", "MemLocker", "(", "c", "context", ".", "Context", ")", "Locker", "{", "return", "&", "memLocker", "{", "clientID", ":", "strings", ".", "Join", "(", "[", "]", "string", "{", "\"", "\"", ",", "info", ".", "RequestID", "(", "c", ")", ",", "}", ",", "\"", "\\x00", "\"", ")", ",", "}", "\n", "}" ]

[ "MemLocker", "returns", "a", "Locker", "instance", "that", "uses", "a", "memcache", "lock", "bound", "to", "the", "current", "request", "ID", "." ]

[ "func", "VerifyIDToken", "(", "c", "context", ".", "Context", ",", "token", "string", ",", "keys", "*", "JSONWebKeySet", ",", "issuer", ",", "audience", "string", ")", "(", "*", "IDToken", ",", "error", ")", "{", "// See https://developers.google.com/identity/protocols/OpenIDConnect#validatinganidtoken", "body", ",", "err", ":=", "keys", ".", "VerifyJWT", "(", "token", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tok", ":=", "&", "IDToken", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "body", ",", "tok", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "exp", ":=", "time", ".", "Unix", "(", "tok", ".", "Exp", ",", "0", ")", "\n", "now", ":=", "clock", ".", "Now", "(", "c", ")", "\n\n", "switch", "{", "case", "tok", ".", "Iss", "!=", "issuer", "&&", "\"", "\"", "+", "tok", ".", "Iss", "!=", "issuer", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "issuer", ",", "tok", ".", "Iss", ")", "\n", "case", "tok", ".", "Aud", "!=", "audience", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "audience", ",", "tok", ".", "Aud", ")", "\n", "case", "!", "tok", ".", "EmailVerified", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tok", ".", "Email", ")", "\n", "case", "tok", ".", "Sub", "==", "\"", "\"", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "case", "exp", ".", "Add", "(", "allowedClockSkew", ")", ".", "Before", "(", "now", ")", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "now", ".", "Sub", "(", "exp", ")", ")", "\n", "}", "\n\n", "return", "tok", ",", "nil", "\n", "}" ]

[ "VerifyIDToken", "deserializes", "and", "verifies", "the", "ID", "token", ".", "This", "is", "a", "fast", "local", "operation", "." ]

[ "func", "(", "g", "*", "GrantsByRole", ")", "CallerHasRole", "(", "c", "context", ".", "Context", ",", "role", "Role", ")", "(", "bool", ",", "error", ")", "{", "switch", "role", "{", "case", "Owner", ":", "return", "hasGrant", "(", "c", ",", "g", ".", "Owners", ",", "groupsAdministrators", ")", "\n", "case", "Triggerer", ":", "return", "hasGrant", "(", "c", ",", "g", ".", "Owners", ",", "g", ".", "Triggerers", ",", "groupsAdministrators", ")", "\n", "case", "Reader", ":", "return", "hasGrant", "(", "c", ",", "g", ".", "Owners", ",", "g", ".", "Readers", ",", "g", ".", "Triggerers", ",", "groupsAdministrators", ")", "\n", "default", ":", "panic", "(", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "}" ]

[ "CallerHasRole", "does", "what", "it", "says", "and", "returns", "only", "transient", "errors", "." ]

[ "func", "ValidateACLSets", "(", "ctx", "*", "validation", ".", "Context", ",", "sets", "[", "]", "*", "messages", ".", "AclSet", ")", "Sets", "{", "as", ":=", "make", "(", "Sets", ",", "len", "(", "sets", ")", ")", "\n", "reportedDups", ":=", "stringset", ".", "New", "(", "len", "(", "sets", ")", ")", "\n", "for", "_", ",", "s", ":=", "range", "sets", "{", "_", ",", "isDup", ":=", "as", "[", "s", ".", "Name", "]", "\n", "validName", ":=", "false", "\n", "switch", "{", "case", "s", ".", "Name", "==", "\"", "\"", ":", "ctx", ".", "Errorf", "(", "\"", "\"", ")", "\n", "case", "!", "aclSetNameRe", ".", "MatchString", "(", "s", ".", "Name", ")", ":", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "Name", ")", "\n", "case", "isDup", ":", "if", "reportedDups", ".", "Add", "(", "s", ".", "Name", ")", "{", "// Report only first dup.", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "Name", ")", "\n", "}", "\n", "default", ":", "validName", "=", "true", "\n", "}", "\n", "// record this error regardless of whether name is valid or not", "if", "len", "(", "s", ".", "GetAcls", "(", ")", ")", "==", "0", "{", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "Name", ")", "\n", "}", "else", "if", "validName", "{", "// add if and only if it is valid", "as", "[", "s", ".", "Name", "]", "=", "s", ".", "GetAcls", "(", ")", "\n", "}", "\n", "}", "\n", "return", "as", "\n", "}" ]

[ "ValidateACLSets", "validates", "list", "of", "AclSet", "of", "a", "project", "and", "returns", "Sets", ".", "Errors", "are", "returned", "via", "validation", ".", "Context", "." ]

[ "func", "ValidateTaskACLs", "(", "ctx", "*", "validation", ".", "Context", ",", "pSets", "Sets", ",", "tSets", "[", "]", "string", ",", "tAcls", "[", "]", "*", "messages", ".", "Acl", ")", "*", "GrantsByRole", "{", "grantsLists", ":=", "make", "(", "[", "]", "[", "]", "*", "messages", ".", "Acl", ",", "0", ",", "1", "+", "len", "(", "tSets", ")", ")", "\n", "ctx", ".", "Enter", "(", "\"", "\"", ")", "\n", "validateGrants", "(", "ctx", ",", "tAcls", ")", "\n", "ctx", ".", "Exit", "(", ")", "\n", "grantsLists", "=", "append", "(", "grantsLists", ",", "tAcls", ")", "\n", "ctx", ".", "Enter", "(", "\"", "\"", ")", "\n", "for", "_", ",", "set", ":=", "range", "tSets", "{", "if", "grantsList", ",", "exists", ":=", "pSets", "[", "set", "]", ";", "exists", "{", "grantsLists", "=", "append", "(", "grantsLists", ",", "grantsList", ")", "\n", "}", "else", "{", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "set", ")", "\n", "}", "\n", "}", "\n", "ctx", ".", "Exit", "(", ")", "\n", "mg", ":=", "mergeGrants", "(", "grantsLists", "...", ")", "\n", "if", "n", ":=", "len", "(", "mg", ".", "Owners", ")", "+", "len", "(", "mg", ".", "Readers", ")", "+", "len", "(", "mg", ".", "Triggerers", ")", ";", "n", ">", "maxGrantsPerJob", "{", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "maxGrantsPerJob", ",", "n", ")", "\n", "}", "\n", "if", "len", "(", "mg", ".", "Owners", ")", "==", "0", "{", "ctx", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "mg", "\n", "}" ]

[ "ValidateTaskACLs", "validates", "task", "s", "ACLs", "and", "returns", "TaskAcls", ".", "Errors", "are", "returned", "via", "validation", ".", "Context", "." ]

[ "func", "validateGrants", "(", "ctx", "*", "validation", ".", "Context", ",", "gs", "[", "]", "*", "messages", ".", "Acl", ")", "{", "for", "_", ",", "g", ":=", "range", "gs", "{", "switch", "{", "case", "g", ".", "GetRole", "(", ")", "!=", "messages", ".", "Acl_OWNER", "&&", "g", ".", "GetRole", "(", ")", "!=", "messages", ".", "Acl_READER", "&&", "g", ".", "GetRole", "(", ")", "!=", "messages", ".", "Acl_TRIGGERER", ":", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "g", ".", "GetRole", "(", ")", ")", "\n", "case", "g", ".", "GetGrantedTo", "(", ")", "==", "\"", "\"", ":", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "g", ".", "GetRole", "(", ")", ")", "\n", "case", "strings", ".", "HasPrefix", "(", "g", ".", "GetGrantedTo", "(", ")", ",", "\"", "\"", ")", ":", "if", "g", ".", "GetGrantedTo", "(", ")", "[", "len", "(", "\"", "\"", ")", ":", "]", "==", "\"", "\"", "{", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "g", ".", "GetGrantedTo", "(", ")", ",", "g", ".", "GetRole", "(", ")", ")", "\n", "}", "\n", "default", ":", "id", ":=", "g", ".", "GetGrantedTo", "(", ")", "\n", "if", "!", "strings", ".", "ContainsRune", "(", "g", ".", "GetGrantedTo", "(", ")", ",", "':'", ")", "{", "id", "=", "\"", "\"", "+", "g", ".", "GetGrantedTo", "(", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "identity", ".", "MakeIdentity", "(", "id", ")", ";", "err", "!=", "nil", "{", "ctx", ".", "Error", "(", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "g", ".", "GetGrantedTo", "(", ")", ",", "g", ".", "GetRole", "(", ")", ")", ".", "Err", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "validateGrants", "validates", "the", "fields", "of", "the", "provided", "grants", ".", "Errors", "are", "returned", "via", "validation", ".", "Context", "." ]

[ "func", "mergeGrants", "(", "grantsLists", "...", "[", "]", "*", "messages", ".", "Acl", ")", "*", "GrantsByRole", "{", "all", ":=", "map", "[", "messages", ".", "Acl_Role", "]", "stringset", ".", "Set", "{", "messages", ".", "Acl_OWNER", ":", "stringset", ".", "New", "(", "maxGrantsPerJob", ")", ",", "messages", ".", "Acl_TRIGGERER", ":", "stringset", ".", "New", "(", "maxGrantsPerJob", ")", ",", "messages", ".", "Acl_READER", ":", "stringset", ".", "New", "(", "maxGrantsPerJob", ")", ",", "}", "\n", "for", "_", ",", "grantsList", ":=", "range", "grantsLists", "{", "for", "_", ",", "g", ":=", "range", "grantsList", "{", "all", "[", "g", ".", "GetRole", "(", ")", "]", ".", "Add", "(", "g", ".", "GetGrantedTo", "(", ")", ")", "\n", "}", "\n", "}", "\n", "sortedSlice", ":=", "func", "(", "s", "stringset", ".", "Set", ")", "[", "]", "string", "{", "r", ":=", "s", ".", "ToSlice", "(", ")", "\n", "sort", ".", "Strings", "(", "r", ")", "\n", "return", "r", "\n", "}", "\n", "return", "&", "GrantsByRole", "{", "Owners", ":", "sortedSlice", "(", "all", "[", "messages", ".", "Acl_OWNER", "]", ")", ",", "Triggerers", ":", "sortedSlice", "(", "all", "[", "messages", ".", "Acl_TRIGGERER", "]", ")", ",", "Readers", ":", "sortedSlice", "(", "all", "[", "messages", ".", "Acl_READER", "]", ")", ",", "}", "\n", "}" ]

[ "mergeGrants", "merges", "valid", "grants", "into", "GrantsByRole", "removing", "and", "sorting", "duplicates", "." ]

[ "func", "hasGrant", "(", "c", "context", ".", "Context", ",", "grantsList", "...", "[", "]", "string", ")", "(", "bool", ",", "error", ")", "{", "currentIdentity", ":=", "auth", ".", "CurrentIdentity", "(", "c", ")", "\n", "var", "groups", "[", "]", "string", "\n", "for", "_", ",", "grants", ":=", "range", "grantsList", "{", "for", "_", ",", "grant", ":=", "range", "grants", "{", "if", "strings", ".", "HasPrefix", "(", "grant", ",", "\"", "\"", ")", "{", "groups", "=", "append", "(", "groups", ",", "grant", "[", "len", "(", "\"", "\"", ")", ":", "]", ")", "\n", "continue", "\n", "}", "\n", "grantedIdentity", ":=", "identity", ".", "Identity", "(", "grant", ")", "\n", "if", "!", "strings", ".", "ContainsRune", "(", "grant", ",", "':'", ")", "{", "// Just email.", "grantedIdentity", "=", "identity", ".", "Identity", "(", "\"", "\"", "+", "grant", ")", "\n", "}", "\n", "if", "grantedIdentity", "==", "currentIdentity", "{", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "isMember", ",", "err", ":=", "auth", ".", "IsMember", "(", "c", ",", "groups", "...", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "else", "{", "return", "isMember", ",", "nil", "\n", "}", "\n", "}" ]

[ "hasGrant", "is", "current", "user", "is", "covered", "by", "any", "given", "grants", "." ]

[ "func", "PropertiesFlag", "(", "props", "*", "structpb", ".", "Struct", ")", "flag", ".", "Getter", "{", "if", "props", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "propertiesFlag", "{", "props", ":", "props", ",", "first", ":", "true", ",", "// We don't expect a lot of properties.", "// After a certain number, it is easier to pass properties via a file.", "// Choose an arbitrary number.", "explicitlySet", ":", "stringset", ".", "New", "(", "4", ")", ",", "}", "\n", "}" ]

[ "PropertiesFlag", "returns", "a", "flag", ".", "Getter", "that", "can", "read", "property", "values", "into", "props", ".", "If", "a", "flag", "value", "starts", "with" ]

[ "func", "(", "s", "*", "State", ")", "Middleware", "(", "c", "*", "router", ".", "Context", ",", "next", "router", ".", "Handler", ")", "{", "state", ",", "settings", ":=", "s", ".", "checkSettings", "(", "c", ".", "Context", ")", "\n", "if", "settings", ".", "Enabled", "{", "started", ":=", "clock", ".", "Now", "(", "c", ".", "Context", ")", "\n", "req", ":=", "c", ".", "Request", "\n", "userAgent", ",", "ok", ":=", "req", ".", "Header", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "||", "len", "(", "userAgent", ")", "==", "0", "{", "userAgent", "=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "}", "\n", "ctx", ":=", "c", ".", "Context", "\n", "contentLength", ":=", "c", ".", "Request", ".", "ContentLength", "\n", "nrw", ":=", "newResponseWriter", "(", "c", ".", "Writer", ")", "\n", "c", ".", "Writer", "=", "nrw", "\n", "defer", "func", "(", ")", "{", "dur", ":=", "clock", ".", "Now", "(", "ctx", ")", ".", "Sub", "(", "started", ")", "\n", "metric", ".", "UpdateServerMetrics", "(", "ctx", ",", "c", ".", "HandlerPath", ",", "nrw", ".", "Status", "(", ")", ",", "dur", ",", "contentLength", ",", "nrw", ".", "Size", "(", ")", ",", "userAgent", "[", "0", "]", ")", "\n", "}", "(", ")", "\n", "next", "(", "c", ")", "\n", "s", ".", "flushIfNeeded", "(", "ctx", ",", "req", ",", "state", ",", "settings", ")", "\n", "}", "else", "{", "next", "(", "c", ")", "\n", "}", "\n", "}" ]

[ "Middleware", "is", "a", "middleware", "that", "collects", "request", "metrics", "and", "triggers", "metric", "flushes", "." ]

[ "func", "(", "s", "*", "State", ")", "checkSettings", "(", "c", "context", ".", "Context", ")", "(", "*", "tsmon", ".", "State", ",", "*", "tsmonSettings", ")", "{", "state", ":=", "tsmon", ".", "GetState", "(", "c", ")", "\n\n", "var", "settings", "tsmonSettings", "\n", "if", "s", ".", "testingSettings", "!=", "nil", "{", "settings", "=", "*", "s", ".", "testingSettings", "\n", "}", "else", "{", "settings", "=", "fetchCachedSettings", "(", "c", ")", "\n", "}", "\n\n", "// Read the values used when handling previous request. In most cases they", "// are identical to current ones and we can skip grabbing a heavier write", "// lock.", "s", ".", "lock", ".", "RLock", "(", ")", "\n", "if", "s", ".", "state", "==", "state", "&&", "s", ".", "lastSettings", "==", "settings", "{", "s", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "state", ",", "&", "settings", "\n", "}", "\n", "s", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "// 'settings' or 'state' has changed. Reinitialize tsmon as needed under", "// the write lock.", "s", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "// First call to 'checkSettings' ever?", "if", "s", ".", "state", "==", "nil", "{", "s", ".", "state", "=", "state", "\n", "s", ".", "state", ".", "SetMonitor", "(", "monitor", ".", "NewNilMonitor", "(", ")", ")", "// doFlush uses its own monitor", "\n", "s", ".", "state", ".", "InhibitGlobalCallbacksOnFlush", "(", ")", "\n", "}", "else", "if", "state", "!=", "s", ".", "state", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "switch", "{", "case", "!", "bool", "(", "s", ".", "lastSettings", ".", "Enabled", ")", "&&", "bool", "(", "settings", ".", "Enabled", ")", ":", "s", ".", "enableTsMon", "(", "c", ")", "\n", "case", "bool", "(", "s", ".", "lastSettings", ".", "Enabled", ")", "&&", "!", "bool", "(", "settings", ".", "Enabled", ")", ":", "s", ".", "disableTsMon", "(", "c", ")", "\n", "}", "\n", "s", ".", "lastSettings", "=", "settings", "\n\n", "return", "state", ",", "&", "settings", "\n", "}" ]

[ "checkSettings", "fetches", "tsmon", "settings", "and", "initializes", "reinitializes", "or", "deinitializes", "tsmon", "as", "needed", ".", "Returns", "current", "tsmon", "state", "and", "settings", ".", "Panics", "if", "the", "context", "is", "using", "unexpected", "tsmon", "state", "." ]

[ "func", "(", "s", "*", "State", ")", "enableTsMon", "(", "c", "context", ".", "Context", ")", "{", "t", ":=", "s", ".", "Target", "(", "c", ")", "\n", "t", ".", "TaskNum", "=", "-", "1", "// will be assigned later via TaskNumAllocator", "\n\n", "s", ".", "state", ".", "SetStore", "(", "store", ".", "NewInMemory", "(", "&", "t", ")", ")", "\n\n", "// Request the flush to be executed ASAP, so it registers a claim for a task", "// number via NotifyTaskIsAlive. Also reset 'lastFlush', so that we don't get", "// invalid logging that the last flush was long time ago.", "s", ".", "nextFlush", "=", "clock", ".", "Now", "(", "c", ")", "\n", "s", ".", "lastFlush", "=", "s", ".", "nextFlush", "\n", "// Set initial value for retry delay.", "s", ".", "flushRetry", "=", "flushInitialRetry", "\n", "}" ]

[ "enableTsMon", "puts", "in", "-", "memory", "metrics", "store", "in", "the", "context", "s", "tsmon", "state", ".", "Called", "with", "s", ".", "lock", "locked", "." ]

[ "func", "(", "s", "*", "State", ")", "disableTsMon", "(", "c", "context", ".", "Context", ")", "{", "s", ".", "state", ".", "SetStore", "(", "store", ".", "NewNilStore", "(", ")", ")", "\n", "}" ]

[ "disableTsMon", "puts", "nil", "metrics", "store", "in", "the", "context", "s", "tsmon", "state", ".", "Called", "with", "s", ".", "lock", "locked", "." ]

[ "func", "(", "s", "*", "State", ")", "flushIfNeeded", "(", "c", "context", ".", "Context", ",", "req", "*", "http", ".", "Request", ",", "state", "*", "tsmon", ".", "State", ",", "settings", "*", "tsmonSettings", ")", "{", "now", ":=", "clock", ".", "Now", "(", "c", ")", "\n\n", "// Most of the time the flush is not needed and we can get away with", "// lightweight RLock.", "s", ".", "lock", ".", "RLock", "(", ")", "\n", "skip", ":=", "s", ".", "flushingNow", "||", "now", ".", "Before", "(", "s", ".", "nextFlush", ")", "\n", "s", ".", "lock", ".", "RUnlock", "(", ")", "\n", "if", "skip", "{", "return", "\n", "}", "\n\n", "// Need to flush. Update flushingNow. Redo the check under write lock, as well", "// as do a bunch of other calls while we hold the lock. Will be useful later.", "s", ".", "lock", ".", "Lock", "(", ")", "\n", "if", "s", ".", "instanceID", "==", "\"", "\"", "{", "s", ".", "instanceID", "=", "s", ".", "InstanceID", "(", "c", ")", "\n", "}", "\n", "instanceID", ":=", "s", ".", "instanceID", "\n", "lastFlush", ":=", "s", ".", "lastFlush", "\n", "skip", "=", "s", ".", "flushingNow", "||", "now", ".", "Before", "(", "s", ".", "nextFlush", ")", "\n", "if", "!", "skip", "{", "s", ".", "flushingNow", "=", "true", "\n", "}", "\n", "s", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "skip", "{", "return", "\n", "}", "\n\n", "// The flush must be fast. Limit it by some timeout.", "c", ",", "cancel", ":=", "clock", ".", "WithTimeout", "(", "c", ",", "flushTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "// Report per-process statistic.", "versions", ".", "Report", "(", "c", ")", "\n", "if", "settings", ".", "ReportRuntimeStats", "{", "runtimestats", ".", "Report", "(", "c", ")", "\n", "}", "\n\n", "// Unset 'flushingNow' no matter what (even on panics).", "// If flush has failed, retry with back off to avoid", "// hammering the receiver.", "var", "err", "error", "\n", "defer", "func", "(", ")", "{", "s", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "lock", ".", "Unlock", "(", ")", "\n", "s", ".", "flushingNow", "=", "false", "\n", "if", "err", "==", "nil", "||", "err", "==", "ErrNoTaskNumber", "{", "// Reset retry delay.", "s", ".", "flushRetry", "=", "flushInitialRetry", "\n", "s", ".", "nextFlush", "=", "now", ".", "Add", "(", "time", ".", "Duration", "(", "settings", ".", "FlushIntervalSec", ")", "*", "time", ".", "Second", ")", "\n", "if", "err", "==", "nil", "{", "s", ".", "lastFlush", "=", "now", "\n", "}", "\n", "}", "else", "{", "// Flush has failed, back off the next flush.", "if", "s", ".", "flushRetry", "<", "flushMaxRetry", "{", "s", ".", "flushRetry", "*=", "2", "\n", "}", "\n", "s", ".", "nextFlush", "=", "now", ".", "Add", "(", "s", ".", "flushRetry", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "err", "=", "s", ".", "ensureTaskNumAndFlush", "(", "c", ",", "instanceID", ",", "state", ",", "settings", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "ErrNoTaskNumber", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "else", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "sinceLastFlush", ":=", "now", ".", "Sub", "(", "lastFlush", ")", ";", "sinceLastFlush", ">", "noFlushErrorThreshold", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "sinceLastFlush", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "flushIfNeeded", "periodically", "flushes", "the", "accumulated", "metrics", ".", "It", "skips", "the", "flush", "if", "some", "other", "goroutine", "is", "already", "flushing", ".", "Logs", "errors", "." ]

[ "func", "(", "s", "*", "State", ")", "ensureTaskNumAndFlush", "(", "c", "context", ".", "Context", ",", "instanceID", "string", ",", "state", "*", "tsmon", ".", "State", ",", "settings", "*", "tsmonSettings", ")", "error", "{", "var", "task", "target", ".", "Task", "\n", "defTarget", ":=", "state", ".", "Store", "(", ")", ".", "DefaultTarget", "(", ")", "\n", "if", "t", ",", "ok", ":=", "defTarget", ".", "(", "*", "target", ".", "Task", ")", ";", "ok", "{", "task", "=", "*", "t", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "defTarget", ",", "defTarget", ")", "\n", "}", "\n\n", "// Notify the task number allocator that we are still alive and grab the", "// TaskNum assigned to us.", "assignedTaskNum", ",", "err", ":=", "s", ".", "TaskNumAllocator", ".", "NotifyTaskIsAlive", "(", "c", ",", "&", "task", ",", "instanceID", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "ErrNoTaskNumber", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "instanceID", ",", "err", ")", "\n", "}", "\n\n", "// Don't do the flush if we still haven't got a task number.", "if", "err", "==", "ErrNoTaskNumber", "{", "if", "task", ".", "TaskNum", ">=", "0", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "state", ".", "ResetCumulativeMetrics", "(", "c", ")", "\n", "}", "\n", "task", ".", "TaskNum", "=", "-", "1", "\n", "state", ".", "Store", "(", ")", ".", "SetDefaultTarget", "(", "&", "task", ")", "\n", "return", "ErrNoTaskNumber", "\n", "}", "\n\n", "task", ".", "TaskNum", "=", "int32", "(", "assignedTaskNum", ")", "\n", "state", ".", "Store", "(", ")", ".", "SetDefaultTarget", "(", "&", "task", ")", "\n", "return", "s", ".", "doFlush", "(", "c", ",", "state", ",", "settings", ")", "\n", "}" ]

[ "ensureTaskNumAndFlush", "gets", "a", "task", "number", "assigned", "to", "the", "process", "and", "flushes", "the", "metrics", ".", "Returns", "ErrNoTaskNumber", "if", "the", "task", "wasn", "t", "assigned", "a", "task", "number", "yet", "." ]

[ "func", "(", "s", "*", "State", ")", "doFlush", "(", "c", "context", ".", "Context", ",", "state", "*", "tsmon", ".", "State", ",", "settings", "*", "tsmonSettings", ")", "error", "{", "var", "mon", "monitor", ".", "Monitor", "\n", "var", "err", "error", "\n\n", "if", "s", ".", "testingMonitor", "!=", "nil", "{", "mon", "=", "s", ".", "testingMonitor", "\n", "}", "else", "if", "s", ".", "IsDevMode", "||", "settings", ".", "ProdXAccount", "==", "\"", "\"", "{", "mon", "=", "monitor", ".", "NewDebugMonitor", "(", "\"", "\"", ")", "\n", "}", "else", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "settings", ".", "ProdXAccount", ")", "\n", "transport", ",", "err", ":=", "auth", ".", "GetRPCTransport", "(", "c", ",", "auth", ".", "AsActor", ",", "auth", ".", "WithServiceAccount", "(", "settings", ".", "ProdXAccount", ")", ",", "auth", ".", "WithScopes", "(", "monitor", ".", "ProdxmonScopes", "...", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "endpoint", ",", "err", ":=", "url", ".", "Parse", "(", "prodXEndpoint", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "mon", ",", "err", "=", "monitor", ".", "NewHTTPMonitor", "(", "c", ",", "&", "http", ".", "Client", "{", "Transport", ":", "transport", "}", ",", "endpoint", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "defer", "mon", ".", "Close", "(", ")", "\n", "if", "err", "=", "state", ".", "Flush", "(", "c", ",", "mon", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "doFlush", "actually", "sends", "the", "metrics", "to", "the", "monitor", "." ]

[ "func", "(", "al", "*", "archiveLogger", ")", "Printf", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "(", "n", "int", ",", "err", "error", ")", "{", "return", "al", ".", "Fprintf", "(", "os", ".", "Stdout", ",", "format", ",", "a", "...", ")", "\n", "}" ]

[ "Print", "acts", "like", "fmt", ".", "Printf", "but", "may", "prepend", "a", "prefix", "to", "format", "depending", "on", "the", "value", "of", "al", ".", "quiet", "." ]

[ "func", "(", "al", "*", "archiveLogger", ")", "Fprintf", "(", "w", "io", ".", "Writer", ",", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "(", "n", "int", ",", "err", "error", ")", "{", "prefix", ":=", "\"", "\\n", "\"", "\n", "if", "al", ".", "quiet", "{", "prefix", "=", "\"", "\"", "\n", "}", "\n", "args", ":=", "[", "]", "interface", "{", "}", "{", "prefix", "}", "\n", "args", "=", "append", "(", "args", ",", "a", "...", ")", "\n", "return", "fmt", ".", "Printf", "(", "\"", "\"", "+", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Print", "acts", "like", "fmt", ".", "fprintf", "but", "may", "prepend", "a", "prefix", "to", "format", "depending", "on", "the", "value", "of", "al", ".", "quiet", "." ]

[ "func", "archive", "(", "ctx", "context", ".", "Context", ",", "client", "*", "isolatedclient", ".", "Client", ",", "opts", "*", "isolate", ".", "ArchiveOptions", ",", "dumpJSON", "string", ",", "concurrentChecks", ",", "concurrentUploads", "int", ",", "al", "archiveLogger", ")", "error", "{", "// Parse the incoming isolate file.", "deps", ",", "rootDir", ",", "isol", ",", "err", ":=", "isolate", ".", "ProcessIsolate", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "opts", ".", "Isolate", ",", "err", ")", "\n", "}", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "opts", ".", "Isolate", ",", "len", "(", "deps", ")", ")", "\n\n", "// Set up a checker and uploader.", "checker", ":=", "archiver", ".", "NewChecker", "(", "ctx", ",", "client", ",", "concurrentChecks", ")", "\n", "uploader", ":=", "archiver", ".", "NewUploader", "(", "ctx", ",", "client", ",", "concurrentUploads", ")", "\n", "archiver", ":=", "archiver", ".", "NewTarringArchiver", "(", "checker", ",", "uploader", ")", "\n\n", "isolSummary", ",", "err", ":=", "archiver", ".", "Archive", "(", "deps", ",", "rootDir", ",", "isol", ",", "opts", ".", "Blacklist", ",", "opts", ".", "Isolated", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "opts", ".", "Isolate", ",", "err", ")", "\n", "}", "\n\n", "// Make sure that all pending items have been checked.", "if", "err", ":=", "checker", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Make sure that all the uploads have completed successfully.", "if", "err", ":=", "uploader", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "printSummary", "(", "al", ",", "isolSummary", ")", "\n", "if", "err", ":=", "dumpSummaryJSON", "(", "dumpJSON", ",", "isolSummary", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "al", ".", "LogSummary", "(", "ctx", ",", "int64", "(", "checker", ".", "Hit", ".", "Count", "(", ")", ")", ",", "int64", "(", "checker", ".", "Miss", ".", "Count", "(", ")", ")", ",", "units", ".", "Size", "(", "checker", ".", "Hit", ".", "Bytes", "(", ")", ")", ",", "units", ".", "Size", "(", "checker", ".", "Miss", ".", "Bytes", "(", ")", ")", ",", "[", "]", "string", "{", "string", "(", "isolSummary", ".", "Digest", ")", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "archive", "performs", "the", "archive", "operation", "for", "an", "isolate", "specified", "by", "opts", ".", "dumpJSON", "is", "the", "path", "to", "write", "a", "JSON", "summary", "of", "the", "uploaded", "isolate", "in", "the", "same", "format", "as", "batch_archive", "." ]

[ "func", "(", "s", "*", "Fake", ")", "Get", "(", "context", ".", "Context", ",", "types", ".", "Metric", ",", "time", ".", "Time", ",", "[", "]", "interface", "{", "}", ")", "interface", "{", "}", "{", "return", "nil", "\n", "}" ]

[ "Get", "does", "nothing", "." ]

[ "func", "Round", "(", "value", "time", ".", "Duration", ",", "resolution", "time", ".", "Duration", ")", "time", ".", "Duration", "{", "if", "value", "<", "0", "{", "value", "-=", "resolution", "/", "2", "\n", "}", "else", "{", "value", "+=", "resolution", "/", "2", "\n", "}", "\n", "return", "value", "/", "resolution", "*", "resolution", "\n", "}" ]

[ "Round", "rounds", "a", "time", ".", "Duration", "at", "round", "." ]

[ "func", "(", "r", "*", "printRun", ")", "RegisterIDFlag", "(", ")", "{", "r", ".", "Flags", ".", "BoolVar", "(", "&", "r", ".", "id", ",", "\"", "\"", ",", "false", ",", "doc", "(", "`\n\t\tPrint only build ids.\n\n\t\tIntended for piping the output into another bb subcommand:\n\t\t\tbb ls -cl myCL -id | bb cancel\n\t`", ")", ")", "\n", "}" ]

[ "RegisterIDFlag", "registers", "-", "id", "flag", "." ]

[ "func", "(", "r", "*", "printRun", ")", "RegisterFieldFlags", "(", ")", "{", "r", ".", "Flags", ".", "BoolVar", "(", "&", "r", ".", "all", ",", "\"", "\"", ",", "false", ",", "doc", "(", "`\n\t\tPrint builds in their entirety.\n\t\tWith -json, prints all build fields.\n\t\tWithout -json, implies -steps and -p.\n\t`", ")", ")", "\n", "r", ".", "Flags", ".", "BoolVar", "(", "&", "r", ".", "steps", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "r", ".", "Flags", ".", "BoolVar", "(", "&", "r", ".", "properties", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "}" ]

[ "RegisterFieldFlags", "registers", "-", "A", "-", "steps", "and", "-", "p", "flags", "." ]

[ "func", "(", "r", "*", "printRun", ")", "FieldMask", "(", ")", "(", "*", "field_mask", ".", "FieldMask", ",", "error", ")", "{", "if", "r", ".", "id", "{", "if", "r", ".", "all", "||", "r", ".", "properties", "||", "r", ".", "steps", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "proto", ".", "Clone", "(", "idFieldMask", ")", ".", "(", "*", "field_mask", ".", "FieldMask", ")", ",", "nil", "\n", "}", "\n\n", "if", "r", ".", "all", "{", "if", "r", ".", "properties", "||", "r", ".", "steps", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "proto", ".", "Clone", "(", "completeBuildFieldMask", ")", ".", "(", "*", "field_mask", ".", "FieldMask", ")", ",", "nil", "\n", "}", "\n\n", "ret", ":=", "&", "field_mask", ".", "FieldMask", "{", "Paths", ":", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "}", ",", "}", "\n\n", "if", "r", ".", "properties", "{", "ret", ".", "Paths", "=", "append", "(", "ret", ".", "Paths", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "r", ".", "steps", "{", "ret", ".", "Paths", "=", "append", "(", "ret", ".", "Paths", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "FieldMask", "returns", "the", "field", "mask", "to", "use", "in", "buildbucket", "requests", "." ]

[ "func", "(", "r", "*", "printRun", ")", "PrintAndDone", "(", "ctx", "context", ".", "Context", ",", "args", "[", "]", "string", ",", "fn", "func", "(", "context", ".", "Context", ",", "string", ")", "(", "*", "pb", ".", "Build", ",", "error", ")", ")", "int", "{", "stdout", ",", "stderr", ":=", "newStdioPrinters", "(", "r", ".", "noColor", ")", "\n", "return", "r", ".", "printAndDone", "(", "ctx", ",", "stdout", ",", "stderr", ",", "args", ",", "fn", ")", "\n", "}" ]

[ "PrintAndDone", "calls", "fn", "for", "each", "argument", "prints", "builds", "and", "returns", "exit", "code", ".", "fn", "is", "called", "concurrently", "but", "builds", "are", "printed", "in", "the", "same", "order", "as", "args", "." ]

[ "func", "argChan", "(", "args", "[", "]", "string", ")", "chan", "string", "{", "ret", ":=", "make", "(", "chan", "string", ")", "\n", "go", "func", "(", ")", "{", "defer", "close", "(", "ret", ")", "\n\n", "if", "len", "(", "args", ")", ">", "0", "{", "for", "_", ",", "a", ":=", "range", "args", "{", "ret", "<-", "strings", ".", "TrimSpace", "(", "a", ")", "\n", "}", "\n", "return", "\n", "}", "\n\n", "reader", ":=", "bufio", ".", "NewReader", "(", "os", ".", "Stdin", ")", "\n", "for", "{", "line", ",", "err", ":=", "reader", ".", "ReadString", "(", "'\\n'", ")", "\n", "line", "=", "strings", ".", "TrimSpace", "(", "line", ")", "\n", "switch", "{", "case", "err", "==", "io", ".", "EOF", ":", "return", "\n", "case", "err", "!=", "nil", ":", "panic", "(", "err", ")", "\n", "case", "len", "(", "line", ")", "==", "0", ":", "continue", "\n", "default", ":", "ret", "<-", "line", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "return", "ret", "\n", "}" ]

[ "argChan", "returns", "a", "channel", "of", "args", ".", "If", "args", "is", "empty", "reads", "from", "stdin", ".", "Trims", "whitespace", "and", "skips", "blank", "lines", ".", "Panics", "if", "reading", "from", "stdin", "fails", "." ]

[ "func", "FindService", "(", "s", "*", "pb", ".", "FileDescriptorSet", ",", "fullName", "string", ")", "(", "file", "*", "pb", ".", "FileDescriptorProto", ",", "serviceIndex", "int", ")", "{", "pkg", ",", "name", ":=", "splitFullName", "(", "fullName", ")", "\n", "for", "_", ",", "f", ":=", "range", "s", ".", "GetFile", "(", ")", "{", "if", "f", ".", "GetPackage", "(", ")", "==", "pkg", "{", "if", "i", ":=", "FindServiceForFile", "(", "f", ",", "name", ")", ";", "i", "!=", "-", "1", "{", "return", "f", ",", "i", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "-", "1", "\n", "}" ]

[ "FindService", "searches", "for", "a", "service", "by", "full", "name", "." ]

[ "func", "FindMessageForFile", "(", "f", "*", "pb", ".", "FileDescriptorProto", ",", "name", "string", ")", "int", "{", "for", "i", ",", "x", ":=", "range", "f", ".", "GetMessageType", "(", ")", "{", "if", "x", ".", "GetName", "(", ")", "==", "name", "{", "return", "i", "\n", "}", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "FindMessageForFile", "searches", "for", "a", "DescriptorProto", "by", "name", "." ]

[ "func", "FindEnumForFile", "(", "f", "*", "pb", ".", "FileDescriptorProto", ",", "name", "string", ")", "int", "{", "for", "i", ",", "x", ":=", "range", "f", ".", "GetEnumType", "(", ")", "{", "if", "x", ".", "GetName", "(", ")", "==", "name", "{", "return", "i", "\n", "}", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "FindEnumForFile", "searches", "for", "an", "EnumDescriptorProto", "by", "name", "." ]

[ "func", "FindMessage", "(", "d", "*", "pb", ".", "DescriptorProto", ",", "name", "string", ")", "int", "{", "for", "i", ",", "x", ":=", "range", "d", ".", "GetNestedType", "(", ")", "{", "if", "x", ".", "GetName", "(", ")", "==", "name", "{", "return", "i", "\n", "}", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "FindMessage", "searches", "for", "a", "nested", "DescriptorProto", "by", "name", "." ]

[ "func", "FindEnum", "(", "d", "*", "pb", ".", "DescriptorProto", ",", "name", "string", ")", "int", "{", "for", "i", ",", "x", ":=", "range", "d", ".", "GetEnumType", "(", ")", "{", "if", "x", ".", "GetName", "(", ")", "==", "name", "{", "return", "i", "\n", "}", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "FindEnum", "searches", "for", "a", "nested", "EnumDescriptorProto", "by", "name", "." ]

[ "func", "FindOneOf", "(", "d", "*", "pb", ".", "DescriptorProto", ",", "name", "string", ")", "int", "{", "for", "i", ",", "x", ":=", "range", "d", ".", "GetOneofDecl", "(", ")", "{", "if", "x", ".", "GetName", "(", ")", "==", "name", "{", "return", "i", "\n", "}", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "FindOneOf", "searches", "for", "a", "nested", "OneofDescriptorProto", "by", "name", "." ]

[ "func", "FindValueByNumber", "(", "e", "*", "pb", ".", "EnumDescriptorProto", ",", "number", "int32", ")", "int", "{", "for", "i", ",", "x", ":=", "range", "e", ".", "GetValue", "(", ")", "{", "if", "x", ".", "GetNumber", "(", ")", "==", "number", "{", "return", "i", "\n", "}", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "FindValueByNumber", "searches", "for", "an", "EnumValueDescriptorProto", "by", "number", "." ]

[ "func", "MergeStrings", "(", "sss", "...", "[", "]", "string", ")", "[", "]", "string", "{", "result", ":=", "[", "]", "string", "{", "}", "\n", "seen", ":=", "map", "[", "string", "]", "bool", "{", "}", "\n", "for", "_", ",", "ss", ":=", "range", "sss", "{", "for", "_", ",", "s", ":=", "range", "ss", "{", "if", "seen", "[", "s", "]", "{", "continue", "\n", "}", "\n", "seen", "[", "s", "]", "=", "true", "\n", "result", "=", "append", "(", "result", ",", "s", ")", "\n", "}", "\n", "}", "\n", "sort", ".", "Strings", "(", "result", ")", "\n", "return", "result", "\n", "}" ]

[ "MergeStrings", "merges", "multiple", "string", "slices", "together", "into", "a", "single", "slice", "removing", "duplicates", "." ]

[ "func", "LogarithmicBatchingPolicy", "(", "maxConcurrentInvs", ",", "maxBatchSize", "int", ",", "logBase", "float64", ")", "(", "Func", ",", "error", ")", "{", "// We use 1.0001 to ensure that operation below returns a value small enough", "// to fit into int and to avoid numerical stability issues resulting from", "// very small values being approximated as 0 and resulting in", "// division-by-zero errors.", "if", "logBase", "<", "1.0001", "{", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "log", ":=", "math", ".", "Log", "(", "logBase", ")", "\n", "return", "basePolicy", "(", "maxConcurrentInvs", ",", "maxBatchSize", ",", "func", "(", "triggers", "[", "]", "*", "internal", ".", "Trigger", ")", "int", "{", "return", "int", "(", "math", ".", "Max", "(", "math", ".", "Log", "(", "float64", "(", "len", "(", "triggers", ")", ")", ")", "/", "log", ",", "1.0", ")", ")", "\n", "}", ")", "\n", "}" ]

[ "LogarithmicBatchingPolicy", "instantiates", "new", "LOGARITHMIC_BATCHING", "policy", "function", ".", "It", "takes", "all", "pending", "triggers", "and", "collapses", "log_k", "N", "of", "them", "into", "one", "new", "invocation", "deriving", "its", "properties", "from", "the", "most", "recent", "trigger", "alone", "." ]

[ "func", "ParseName", "(", "v", "string", ")", "(", "wn", "Name", ",", "err", "error", ")", "{", "base", ":=", "strings", ".", "TrimSuffix", "(", "v", ",", "\"", "\"", ")", "\n", "if", "len", "(", "base", ")", "==", "len", "(", "v", ")", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "skip", ":=", "0", "\n", "switch", "parts", ":=", "strings", ".", "Split", "(", "base", ",", "\"", "\"", ")", ";", "len", "(", "parts", ")", "{", "case", "6", ":", "// Extra part: build tag.", "wn", ".", "BuildTag", "=", "parts", "[", "2", "]", "\n", "skip", "=", "1", "\n", "fallthrough", "\n\n", "case", "5", ":", "wn", ".", "Distribution", "=", "parts", "[", "0", "]", "\n", "wn", ".", "Version", "=", "parts", "[", "1", "]", "\n", "wn", ".", "PythonTag", "=", "parts", "[", "2", "+", "skip", "]", "\n", "wn", ".", "ABITag", "=", "parts", "[", "3", "+", "skip", "]", "\n", "wn", ".", "PlatformTag", "=", "parts", "[", "4", "+", "skip", "]", "\n\n", "default", ":", "err", "=", "errors", ".", "Reason", "(", "\"", "\"", ",", "len", "(", "parts", ")", ")", ".", "Err", "(", ")", "\n", "return", "\n", "}", "\n", "return", "\n", "}" ]

[ "ParseName", "parses", "a", "wheel", "Name", "from", "its", "filename", "." ]

[ "func", "ScanDir", "(", "dir", "string", ")", "(", "[", "]", "Name", ",", "error", ")", "{", "globPattern", ":=", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", "\n", "matches", ",", "err", ":=", "filepath", ".", "Glob", "(", "globPattern", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "dir", ")", ".", "InternalReason", "(", "\"", "\"", ",", "globPattern", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "names", ":=", "make", "(", "[", "]", "Name", ",", "0", ",", "len", "(", "matches", ")", ")", "\n", "for", "_", ",", "match", ":=", "range", "matches", "{", "switch", "st", ",", "err", ":=", "os", ".", "Stat", "(", "match", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "match", ")", ".", "Err", "(", ")", "\n\n", "case", "st", ".", "IsDir", "(", ")", ":", "// Ignore directories.", "continue", "\n\n", "default", ":", "// A \".whl\" file.", "name", ":=", "filepath", ".", "Base", "(", "match", ")", "\n", "wheelName", ",", "err", ":=", "ParseName", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "name", ")", ".", "InternalReason", "(", "\"", "\"", ",", "dir", ")", ".", "Err", "(", ")", "\n", "}", "\n", "names", "=", "append", "(", "names", ",", "wheelName", ")", "\n", "}", "\n", "}", "\n", "return", "names", ",", "nil", "\n", "}" ]

[ "ScanDir", "identifies", "all", "wheel", "files", "in", "the", "immediate", "directory", "dir", "and", "returns", "their", "parsed", "wheel", "names", "." ]

[ "func", "ConfigsHandler", "(", "c", "*", "router", ".", "Context", ")", "{", "consoles", ",", "err", ":=", "common", ".", "GetAllConsoles", "(", "c", ".", "Context", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "ErrorHandler", "(", "c", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", ")", "\n", "return", "\n", "}", "\n", "sc", ",", "err", ":=", "common", ".", "GetCurrentServiceConfig", "(", "c", ".", "Context", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "datastore", ".", "ErrNoSuchEntity", "{", "ErrorHandler", "(", "c", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", ")", "\n", "return", "\n", "}", "\n\n", "templates", ".", "MustRender", "(", "c", ".", "Context", ",", "c", ".", "Writer", ",", "\"", "\"", ",", "templates", ".", "Args", "{", "\"", "\"", ":", "consoles", ",", "\"", "\"", ":", "sc", ",", "}", ")", "\n", "}" ]

[ "ConfigsHandler", "renders", "the", "page", "showing", "the", "currently", "loaded", "set", "of", "luci", "-", "configs", "." ]

[ "func", "UpdateConfigHandler", "(", "ctx", "*", "router", ".", "Context", ")", "{", "c", ",", "h", ":=", "ctx", ".", "Context", ",", "ctx", ".", "Writer", "\n", "// Needed to access the PubSub API", "c", "=", "appengine", ".", "WithContext", "(", "c", ",", "ctx", ".", "Request", ")", "\n", "projErr", ":=", "common", ".", "UpdateConsoles", "(", "c", ")", "\n", "if", "projErr", "!=", "nil", "{", "if", "merr", ",", "ok", ":=", "projErr", ".", "(", "errors", ".", "MultiError", ")", ";", "ok", "{", "for", "_", ",", "ierr", ":=", "range", "merr", "{", "logging", ".", "WithError", "(", "ierr", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "{", "logging", ".", "WithError", "(", "projErr", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "settings", ",", "servErr", ":=", "common", ".", "UpdateServiceConfig", "(", "c", ")", "\n", "if", "servErr", "!=", "nil", "{", "logging", ".", "WithError", "(", "servErr", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "else", "{", "servErr", "=", "common", ".", "EnsurePubSubSubscribed", "(", "c", ",", "settings", ")", "\n", "if", "servErr", "!=", "nil", "{", "logging", ".", "WithError", "(", "servErr", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "projErr", "!=", "nil", "||", "servErr", "!=", "nil", "{", "h", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "return", "\n", "}", "\n", "h", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "}" ]

[ "UpdateHandler", "is", "an", "HTTP", "handler", "that", "handles", "configuration", "update", "requests", "." ]

[ "func", "(", "s", "Status", ")", "Final", "(", ")", "bool", "{", "switch", "s", "{", "case", "StatusSucceeded", ",", "StatusFailed", ",", "StatusOverrun", ",", "StatusAborted", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "Final", "returns", "true", "if", "Status", "represents", "some", "final", "status", "." ]

[ "func", "(", "r", "*", "Request", ")", "TriggerIDs", "(", ")", "[", "]", "string", "{", "ids", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "r", ".", "IncomingTriggers", ")", ")", "\n", "for", "i", ",", "t", ":=", "range", "r", ".", "IncomingTriggers", "{", "ids", "[", "i", "]", "=", "t", ".", "Id", "\n", "}", "\n", "return", "ids", "\n", "}" ]

[ "TriggerIDs", "extracts", "list", "of", "IDs", "from", "IncomingTriggers", ".", "This", "is", "useful", "in", "tests", "for", "asserts", "." ]

[ "func", "(", "r", "*", "Request", ")", "StringProperty", "(", "k", "string", ")", "string", "{", "if", "r", ".", "Properties", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "prop", ":=", "r", ".", "Properties", ".", "Fields", "[", "k", "]", "\n", "if", "prop", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "prop", ".", "GetStringValue", "(", ")", "\n", "}" ]

[ "StringProperty", "returns", "a", "value", "of", "string", "property", "or", "if", "no", "such", "property", "or", "it", "has", "a", "different", "type", ".", "This", "is", "useful", "in", "tests", "for", "asserts", "." ]

[ "func", "(", "o", "*", "CacheOptions", ")", "WrapBackend", "(", "c", "context", ".", "Context", ",", "base", "backend", ".", "B", ")", "context", ".", "Context", "{", "return", "backend", ".", "WithFactory", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "backend", ".", "B", "{", "// Start with our base Backend.", "be", ":=", "base", "\n\n", "// If our datastore cache is available, fetch settings to see if it's", "// enabled.", "if", "o", ".", "DatastoreCacheAvailable", "{", "switch", "s", ",", "err", ":=", "gaeconfig", ".", "FetchCachedSettings", "(", "c", ")", ";", "err", "{", "case", "nil", ":", "// Successfully fetched settings, is our datastore cache enabled?", "switch", "s", ".", "DatastoreCacheMode", "{", "case", "gaeconfig", ".", "DSCacheEnabled", ":", "// Datastore cache is enabled, do we have an expiration configured?", "exp", ":=", "time", ".", "Duration", "(", "s", ".", "CacheExpirationSec", ")", "*", "time", ".", "Second", "\n", "if", "exp", ">", "0", "{", "// The cache enabled enable. Install it into our backend.", "locker", ":=", "&", "dsCacheLocker", "{", "}", "\n", "dsCfg", ":=", "datastore", ".", "Config", "{", "RefreshInterval", ":", "exp", ",", "LockerFunc", ":", "func", "(", "context", ".", "Context", ")", "datastorecache", ".", "Locker", "{", "return", "locker", "}", ",", "}", "\n", "be", "=", "dsCfg", ".", "Backend", "(", "be", ")", "\n", "}", "\n", "}", "\n\n", "default", ":", "log", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "// Add a proccache-based config cache.", "if", "o", ".", "CacheExpiration", ">", "0", "{", "be", "=", "caching", ".", "LRUBackend", "(", "be", ",", "messageCache", ".", "LRU", "(", "c", ")", ",", "o", ".", "CacheExpiration", ")", "\n", "}", "\n\n", "return", "be", "\n", "}", ")", "\n", "}" ]

[ "WrapBackend", "wraps", "the", "supplied", "base", "backend", "in", "caching", "layers", "and", "returns", "a", "Context", "with", "the", "resulting", "backend", "installed", "." ]

[ "func", "(", "g", "*", "Generator", ")", "Render", "(", "templ", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "g", ".", "loader", "==", "nil", "{", "g", ".", "loader", "=", "&", "symbols", ".", "Loader", "{", "Source", ":", "g", ".", "Starlark", "}", "\n", "g", ".", "links", "=", "map", "[", "string", "]", "*", "symbol", "{", "}", "\n", "}", "\n\n", "t", ",", "err", ":=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "g", ".", "funcMap", "(", ")", ")", ".", "Parse", "(", "templ", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "buf", ":=", "bytes", ".", "Buffer", "{", "}", "\n", "if", "err", ":=", "t", ".", "Execute", "(", "&", "buf", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "buf", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "Render", "renders", "the", "given", "text", "template", "in", "an", "environment", "with", "access", "to", "parsed", "structured", "Starlark", "comments", "." ]

[ "func", "(", "g", "*", "Generator", ")", "funcMap", "(", ")", "template", ".", "FuncMap", "{", "return", "template", ".", "FuncMap", "{", "\"", "\"", ":", "escapeMD", ",", "\"", "\"", ":", "g", ".", "symbol", ",", "\"", "\"", ":", "g", ".", "linkifySymbols", ",", "}", "\n", "}" ]

[ "funcMap", "are", "functions", "available", "to", "templates", "." ]

[ "func", "(", "g", "*", "Generator", ")", "linkifySymbols", "(", "text", "string", ")", "string", "{", "return", "symRefRe", ".", "ReplaceAllStringFunc", "(", "text", ",", "func", "(", "match", "string", ")", "string", "{", "if", "sym", ":=", "g", ".", "links", "[", "strings", ".", "TrimSuffix", "(", "match", ",", "\"", "\"", ")", "]", ";", "sym", "!=", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "match", ",", "sym", ".", "Anchor", "(", ")", ")", "\n", "}", "else", "{", "return", "match", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "linkifySymbols", "replaces", "recognized", "symbol", "names", "with", "markdown", "links", "to", "symbols", "." ]

[ "func", "(", "s", "*", "symbol", ")", "Flavor", "(", ")", "string", "{", "switch", "s", ".", "Symbol", ".", "(", "type", ")", "{", "case", "*", "symbols", ".", "Term", ":", "switch", "s", ".", "Symbol", ".", "Def", "(", ")", ".", "(", "type", ")", "{", "case", "*", "ast", ".", "Function", ":", "return", "\"", "\"", "\n", "case", "*", "ast", ".", "Var", ":", "return", "\"", "\"", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "case", "*", "symbols", ".", "Invocation", ":", "return", "\"", "\"", "\n", "case", "*", "symbols", ".", "Struct", ":", "return", "\"", "\"", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "Flavor", "returns", "one", "of", "func", "var", "struct", "unknown", "." ]

[ "func", "(", "s", "*", "symbol", ")", "HasDocTag", "(", "tag", "string", ")", "bool", "{", "if", "s", ".", "tags", "==", "nil", "{", "s", ".", "tags", "=", "stringset", ".", "Set", "{", "}", "\n", "for", "_", ",", "word", ":=", "range", "strings", ".", "Fields", "(", "s", ".", "Doc", "(", ")", ".", "RemarkBlock", "(", "\"", "\"", ")", ".", "Body", ")", "{", "s", ".", "tags", ".", "Add", "(", "strings", ".", "ToLower", "(", "strings", ".", "Trim", "(", "word", ",", "\"", "\"", ")", ")", ")", "\n", "}", "\n", "}", "\n", "return", "s", ".", "tags", ".", "Has", "(", "strings", ".", "ToLower", "(", "tag", ")", ")", "\n", "}" ]

[ "HasDocTag", "returns", "true", "if", "the", "docstring", "has", "a", "section", "DocTags", "and", "the", "given", "tag", "is", "listed", "there", ".", "Used", "to", "mark", "some", "symbols", "as", "advanced", "or", "experimental", "." ]

[ "func", "(", "s", "*", "symbol", ")", "Anchor", "(", "sub", "...", "string", ")", "string", "{", "return", "strings", ".", "Join", "(", "append", "(", "[", "]", "string", "{", "s", ".", "FullName", "}", ",", "sub", "...", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "Anchor", "returns", "a", "markdown", "anchor", "name", "that", "can", "be", "used", "to", "link", "to", "some", "part", "of", "this", "symbol", "s", "documentation", "from", "other", "parts", "of", "the", "doc", "." ]

[ "func", "(", "srv", "*", "Config", ")", "Delete", "(", "c", "context", ".", "Context", ",", "req", "*", "config", ".", "DeleteRequest", ")", "(", "*", "empty", ".", "Empty", ",", "error", ")", "{", "srv", ".", "cfg", ".", "Delete", "(", "req", ".", "GetId", "(", ")", ")", "\n", "return", "&", "empty", ".", "Empty", "{", "}", ",", "nil", "\n", "}" ]

[ "Delete", "handles", "a", "request", "to", "delete", "a", "config", "." ]

[ "func", "(", "srv", "*", "Config", ")", "Ensure", "(", "c", "context", ".", "Context", ",", "req", "*", "config", ".", "EnsureRequest", ")", "(", "*", "config", ".", "Config", ",", "error", ")", "{", "srv", ".", "cfg", ".", "Store", "(", "req", ".", "GetId", "(", ")", ",", "req", ".", "GetConfig", "(", ")", ")", "\n", "return", "req", ".", "GetConfig", "(", ")", ",", "nil", "\n", "}" ]

[ "Ensure", "handles", "a", "request", "to", "create", "or", "update", "a", "config", "." ]

[ "func", "(", "crl", "*", "CRL", ")", "GetStatusProto", "(", ")", "*", "admin", ".", "CRLStatus", "{", "return", "&", "admin", ".", "CRLStatus", "{", "LastUpdateTime", ":", "google", ".", "NewTimestamp", "(", "crl", ".", "LastUpdateTime", ")", ",", "LastFetchTime", ":", "google", ".", "NewTimestamp", "(", "crl", ".", "LastFetchTime", ")", ",", "LastFetchEtag", ":", "crl", ".", "LastFetchETag", ",", "RevokedCertsCount", ":", "int64", "(", "crl", ".", "RevokedCertsCount", ")", ",", "}", "\n", "}" ]

[ "GetStatusProto", "returns", "populated", "CRLStatus", "proto", "message", "." ]

[ "func", "updateCRLShard", "(", "c", "context", ".", "Context", ",", "cn", "string", ",", "shard", "shards", ".", "Shard", ",", "count", ",", "idx", "int", ")", "error", "{", "blob", ":=", "shard", ".", "Serialize", "(", ")", "\n", "hash", ":=", "sha1", ".", "Sum", "(", "blob", ")", "\n", "digest", ":=", "hex", ".", "EncodeToString", "(", "hash", "[", ":", "]", ")", "\n\n", "// Have it already?", "header", ":=", "CRLShardHeader", "{", "ID", ":", "shardEntityID", "(", "cn", ",", "count", ",", "idx", ")", "}", "\n", "switch", "err", ":=", "ds", ".", "Get", "(", "c", ",", "&", "header", ")", ";", "{", "case", "err", "!=", "nil", "&&", "err", "!=", "ds", ".", "ErrNoSuchEntity", ":", "return", "err", "\n", "case", "err", "==", "nil", "&&", "header", ".", "SHA1", "==", "digest", ":", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "cn", ",", "idx", ",", "count", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// Zip before uploading.", "zipped", ",", "err", ":=", "utils", ".", "ZlibCompress", "(", "blob", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "cn", ",", "idx", ",", "count", ",", "len", "(", "zipped", ")", ",", "100", "*", "len", "(", "zipped", ")", "/", "len", "(", "blob", ")", ")", "\n\n", "// Upload, updating the header and the body at once.", "return", "ds", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "header", ".", "SHA1", "=", "digest", "\n", "body", ":=", "CRLShardBody", "{", "Parent", ":", "ds", ".", "KeyForObj", "(", "c", ",", "&", "header", ")", ",", "SHA1", ":", "digest", ",", "ZippedData", ":", "zipped", ",", "}", "\n", "return", "ds", ".", "Put", "(", "c", ",", "&", "header", ",", "&", "body", ")", "\n", "}", ",", "nil", ")", "\n", "}" ]

[ "updateCRLShard", "updates", "entities", "that", "holds", "a", "single", "shard", "of", "a", "CRL", "set", "." ]

[ "func", "shardEntityID", "(", "cn", "string", ",", "total", ",", "index", "int", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cn", ",", "total", ",", "index", ")", "\n", "}" ]

[ "shardEntityID", "returns", "an", "ID", "of", "CRLShardHeader", "entity", "for", "given", "shard", ".", "cn", "is", "Common", "Name", "of", "the", "CRL", ".", "total", "is", "total", "number", "of", "shards", "expected", "and", "index", "is", "an", "index", "of", "some", "particular", "shard", "." ]

[ "func", "(", "ch", "*", "CRLChecker", ")", "IsRevokedSN", "(", "c", "context", ".", "Context", ",", "sn", "*", "big", ".", "Int", ")", "(", "bool", ",", "error", ")", "{", "snBlob", ",", "err", ":=", "utils", ".", "SerializeSN", "(", "sn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "shard", ",", "err", ":=", "ch", ".", "shard", "(", "c", ",", "shards", ".", "ShardIndex", "(", "snBlob", ",", "ch", ".", "shardCount", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "_", ",", "revoked", ":=", "shard", "[", "string", "(", "snBlob", ")", "]", "\n", "return", "revoked", ",", "nil", "\n", "}" ]

[ "IsRevokedSN", "returns", "true", "if", "given", "serial", "number", "is", "in", "the", "CRL", "." ]

[ "func", "(", "ch", "*", "CRLChecker", ")", "shard", "(", "c", "context", ".", "Context", ",", "idx", "int", ")", "(", "shards", ".", "Shard", ",", "error", ")", "{", "val", ",", "err", ":=", "ch", ".", "shards", "[", "idx", "]", ".", "Get", "(", "c", ",", "func", "(", "prev", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "time", ".", "Duration", ",", "error", ")", "{", "prevState", ",", "_", ":=", "prev", ".", "(", "shardCache", ")", "\n", "newState", ",", "err", ":=", "ch", ".", "refetchShard", "(", "c", ",", "idx", ",", "prevState", ")", "\n", "return", "newState", ",", "ch", ".", "cacheDuration", ",", "err", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// lazyslot.Get always returns non-nil val on success. It is safe to cast it", "// to whatever we returned in the callback (which is always shardCache, see", "// refetchShard).", "return", "val", ".", "(", "shardCache", ")", ".", "shard", ",", "nil", "\n", "}" ]

[ "shard", "returns", "a", "shard", "given", "its", "index", "." ]

[ "func", "(", "ch", "*", "CRLChecker", ")", "refetchShard", "(", "c", "context", ".", "Context", ",", "idx", "int", ",", "prevState", "shardCache", ")", "(", "newState", "shardCache", ",", "err", "error", ")", "{", "// Have something locally already? Quickly fetch CRLShardHeader to check", "// whether we need to pull a heavy CRLShardBody.", "hdr", ":=", "CRLShardHeader", "{", "ID", ":", "shardEntityID", "(", "ch", ".", "cn", ",", "ch", ".", "shardCount", ",", "idx", ")", "}", "\n", "if", "prevState", ".", "sha1", "!=", "\"", "\"", "{", "switch", "err", "=", "ds", ".", "Get", "(", "c", ",", "&", "hdr", ")", ";", "{", "case", "err", "==", "ds", ".", "ErrNoSuchEntity", ":", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "hdr", ".", "ID", ")", "\n", "return", "\n", "case", "err", "!=", "nil", ":", "err", "=", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "return", "\n", "}", "\n", "// The currently cached copy is still good enough?", "if", "hdr", ".", "SHA1", "==", "prevState", ".", "sha1", "{", "newState", "=", "prevState", "\n", "return", "\n", "}", "\n", "}", "\n\n", "// Nothing is cached, or the datastore copy is fresher than what we have in", "// the cache. Need to fetch a new copy, unzip and deserialize it. This entity", "// is prepared by updateCRLShard.", "body", ":=", "CRLShardBody", "{", "Parent", ":", "ds", ".", "KeyForObj", "(", "c", ",", "&", "hdr", ")", "}", "\n", "switch", "err", "=", "ds", ".", "Get", "(", "c", ",", "&", "body", ")", ";", "{", "case", "err", "==", "ds", ".", "ErrNoSuchEntity", ":", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "hdr", ".", "ID", ")", "\n", "return", "\n", "case", "err", "!=", "nil", ":", "err", "=", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "return", "\n", "}", "\n\n", "// Unzip and deserialize.", "blob", ",", "err", ":=", "utils", ".", "ZlibDecompress", "(", "body", ".", "ZippedData", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "shard", ",", "err", ":=", "shards", ".", "ParseShard", "(", "blob", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "newState", "=", "shardCache", "{", "shard", ":", "shard", ",", "sha1", ":", "body", ".", "SHA1", "}", "\n", "return", "\n", "}" ]

[ "refetchShard", "is", "called", "by", "shard", "to", "fetch", "a", "new", "version", "of", "a", "shard", "." ]

[ "func", "(", "b", "BuilderID", ")", "Get", "(", "c", "context", ".", "Context", ",", "limit", "int", ",", "cursor", "string", ")", "(", "*", "ui", ".", "Builder", ",", "error", ")", "{", "// TODO(iannucci): replace these implementations with a BuildSummary query.", "source", ",", "group", ",", "builderName", ",", "err", ":=", "b", ".", "Split", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "builder", "*", "ui", ".", "Builder", "\n", "var", "consoles", "[", "]", "*", "common", ".", "Console", "\n", "err", "=", "parallel", ".", "FanOutIn", "(", "func", "(", "work", "chan", "<-", "func", "(", ")", "error", ")", "{", "work", "<-", "func", "(", ")", "(", "err", "error", ")", "{", "switch", "source", "{", "case", "\"", "\"", ":", "builder", ",", "err", "=", "buildbot", ".", "GetBuilder", "(", "c", ",", "group", ",", "builderName", ",", "limit", ",", "cursor", ")", "\n", "case", "\"", "\"", ":", "bid", ":=", "buildbucket", ".", "NewBuilderID", "(", "group", ",", "builderName", ")", "\n", "builder", ",", "err", "=", "buildbucket", ".", "GetBuilder", "(", "c", ",", "bid", ",", "limit", ",", "cursor", ")", "\n", "default", ":", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "source", ")", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "work", "<-", "func", "(", ")", "(", "err", "error", ")", "{", "consoles", ",", "err", "=", "common", ".", "GetAllConsoles", "(", "c", ",", "string", "(", "b", ")", ")", "\n", "return", "\n", "}", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "builder", ".", "Groups", "=", "make", "(", "[", "]", "*", "ui", ".", "Link", ",", "len", "(", "consoles", ")", ")", "\n", "for", "i", ",", "c", ":=", "range", "consoles", "{", "builder", ".", "Groups", "[", "i", "]", "=", "ui", ".", "NewLink", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "ProjectID", "(", ")", ",", "c", ".", "ID", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "ProjectID", "(", ")", ",", "c", ".", "ID", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "ID", ",", "c", ".", "ProjectID", "(", ")", ")", ")", "\n", "}", "\n", "sort", ".", "Slice", "(", "builder", ".", "Groups", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "builder", ".", "Groups", "[", "i", "]", ".", "Label", "<", "builder", ".", "Groups", "[", "j", "]", ".", "Label", "\n", "}", ")", "\n\n", "for", "_", ",", "b", ":=", "range", "builder", ".", "FinishedBuilds", "{", "if", "len", "(", "b", ".", "Blame", ")", ">", "0", "{", "builder", ".", "HasBlamelist", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "return", "builder", ",", "nil", "\n", "}" ]

[ "Get", "allows", "you", "to", "obtain", "the", "resp", ".", "Builder", "that", "corresponds", "with", "this", "BuilderID", "." ]

[ "func", "(", "b", "BuilderID", ")", "SelfLink", "(", "project", "string", ")", "string", "{", "return", "model", ".", "BuilderIDLink", "(", "string", "(", "b", ")", ",", "project", ")", "\n", "}" ]

[ "SelfLink", "returns", "LUCI", "URL", "of", "the", "builder", "." ]

[ "func", "NewClient", "(", "c", "context", ".", "Context", ",", "host", "string", ")", "(", "*", "coordinator", ".", "Client", ",", "error", ")", "{", "if", "client", ",", "_", ":=", "c", ".", "Value", "(", "&", "fakeLogKey", ")", ".", "(", "logdog", ".", "LogsClient", ")", ";", "client", "!=", "nil", "{", "return", "&", "coordinator", ".", "Client", "{", "C", ":", "client", ",", "Host", ":", "\"", "\"", ",", "}", ",", "nil", "\n", "}", "\n\n", "var", "err", "error", "\n", "if", "host", ",", "err", "=", "resolveHost", "(", "host", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Initialize the LogDog client authentication.", "t", ",", "err", ":=", "auth", ".", "GetRPCTransport", "(", "c", ",", "auth", ".", "AsUser", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Setup our LogDog client.", "return", "coordinator", ".", "NewClient", "(", "&", "prpc", ".", "Client", "{", "C", ":", "&", "http", ".", "Client", "{", "Transport", ":", "t", ",", "}", ",", "Host", ":", "host", ",", "}", ")", ",", "nil", "\n", "}" ]

[ "NewClient", "generates", "a", "new", "LogDog", "client", "that", "issues", "requests", "on", "behalf", "of", "the", "current", "user", "." ]

[ "func", "getLogDogAnnotationAddr", "(", "c", "context", ".", "Context", ",", "build", "*", "buildbot", ".", "Build", ")", "(", "*", "types", ".", "StreamAddr", ",", "error", ")", "{", "if", "v", ",", "ok", ":=", "build", ".", "PropertyValue", "(", "\"", "\"", ")", ".", "(", "string", ")", ";", "ok", "&&", "v", "!=", "\"", "\"", "{", "return", "types", ".", "ParseURL", "(", "v", ")", "\n", "}", "\n", "return", "nil", ",", "grpcutil", ".", "Errf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ")", "\n", "}" ]

[ "Resolve", "LogDog", "annotation", "stream", "for", "this", "build", "." ]

[ "func", "mergeBuildIntoAnnotation", "(", "c", "context", ".", "Context", ",", "step", "*", "miloProto", ".", "Step", ",", "build", "*", "buildbot", ".", "Build", ")", "error", "{", "allProps", ":=", "stringset", ".", "New", "(", "len", "(", "step", ".", "Property", ")", "+", "len", "(", "build", ".", "Properties", ")", ")", "\n", "for", "_", ",", "prop", ":=", "range", "step", ".", "Property", "{", "allProps", ".", "Add", "(", "prop", ".", "Name", ")", "\n", "}", "\n", "for", "_", ",", "prop", ":=", "range", "build", ".", "Properties", "{", "// Annotation protobuf overrides BuildBot properties.", "if", "allProps", ".", "Has", "(", "prop", ".", "Name", ")", "{", "continue", "\n", "}", "\n", "allProps", ".", "Add", "(", "prop", ".", "Name", ")", "\n\n", "step", ".", "Property", "=", "append", "(", "step", ".", "Property", ",", "&", "miloProto", ".", "Step_Property", "{", "Name", ":", "prop", ".", "Name", ",", "Value", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "prop", ".", "Value", ")", ",", "}", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "mergeBuildInfoIntoAnnotation", "merges", "BuildBot", "-", "specific", "build", "informtion", "into", "a", "LogDog", "annotation", "protobuf", ".", "This", "consists", "of", "augmenting", "the", "Step", "s", "properties", "with", "BuildBot", "s", "properties", "favoring", "the", "Step", "s", "version", "of", "the", "properties", "if", "there", "are", "two", "with", "the", "same", "name", "." ]

[ "func", "(", "r", "*", "FetchCRLRPC", ")", "FetchCRL", "(", "c", "context", ".", "Context", ",", "req", "*", "admin", ".", "FetchCRLRequest", ")", "(", "*", "admin", ".", "FetchCRLResponse", ",", "error", ")", "{", "// Grab a corresponding CA entity. It contains URL of CRL to fetch.", "ca", ":=", "&", "CA", "{", "CN", ":", "req", ".", "Cn", "}", "\n", "switch", "err", ":=", "ds", ".", "Get", "(", "c", ",", "ca", ")", ";", "{", "case", "err", "==", "ds", ".", "ErrNoSuchEntity", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ",", "ca", ".", "CN", ")", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Grab CRL URL from the CA config.", "cfg", ",", "err", ":=", "ca", ".", "ParseConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "cfg", ".", "CrlUrl", "==", "\"", "\"", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ",", "ca", ".", "CN", ")", "\n", "}", "\n\n", "// Grab info about last processed CRL, if any.", "crl", ":=", "&", "CRL", "{", "Parent", ":", "ds", ".", "KeyForObj", "(", "c", ",", "ca", ")", "}", "\n", "if", "err", "=", "ds", ".", "Get", "(", "c", ",", "crl", ")", ";", "err", "!=", "nil", "&&", "err", "!=", "ds", ".", "ErrNoSuchEntity", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Fetch latest CRL blob.", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "ca", ".", "CN", ",", "cfg", ".", "CrlUrl", ")", "\n", "knownETag", ":=", "crl", ".", "LastFetchETag", "\n", "if", "req", ".", "Force", "{", "knownETag", "=", "\"", "\"", "\n", "}", "\n", "fetchCtx", ",", "_", ":=", "clock", ".", "WithTimeout", "(", "c", ",", "time", ".", "Minute", ")", "\n", "crlDer", ",", "newEtag", ",", "err", ":=", "fetchCRL", "(", "fetchCtx", ",", "cfg", ",", "knownETag", ")", "\n", "switch", "{", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Unknown", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// No changes?", "if", "knownETag", "!=", "\"", "\"", "&&", "knownETag", "==", "newEtag", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "knownETag", ")", "\n", "}", "else", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "len", "(", "crlDer", ")", ",", "newEtag", ")", "\n", "crl", ",", "err", "=", "validateAndStoreCRL", "(", "c", ",", "crlDer", ",", "newEtag", ",", "ca", ",", "crl", ")", "\n", "switch", "{", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Unknown", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "&", "admin", ".", "FetchCRLResponse", "{", "CrlStatus", ":", "crl", ".", "GetStatusProto", "(", ")", "}", ",", "nil", "\n", "}" ]

[ "FetchCRL", "makes", "the", "server", "fetch", "a", "CRL", "for", "some", "CA", "." ]

[ "func", "validateAndStoreCRL", "(", "c", "context", ".", "Context", ",", "crlDer", "[", "]", "byte", ",", "etag", "string", ",", "ca", "*", "CA", ",", "prev", "*", "CRL", ")", "(", "*", "CRL", ",", "error", ")", "{", "// Make sure it is signed by the CA.", "caCert", ",", "err", ":=", "x509", ".", "ParseCertificate", "(", "ca", ".", "Cert", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "crl", ",", "err", ":=", "x509", ".", "ParseDERCRL", "(", "crlDer", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", "=", "caCert", ".", "CheckCRLSignature", "(", "crl", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// The CRL is peachy. Update a sharded set of all revoked certs.", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "crl", ".", "TBSCertList", ".", "ThisUpdate", ")", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "len", "(", "crl", ".", "TBSCertList", ".", "RevokedCertificates", ")", ")", "\n", "if", "err", "=", "UpdateCRLSet", "(", "c", ",", "ca", ".", "CN", ",", "CRLShardCount", ",", "crl", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n\n", "// Update the CRL entity. Use EntityVersion to make sure we are not", "// overwriting someone else's changes.", "var", "updated", "*", "CRL", "\n", "err", "=", "ds", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "entity", ":=", "*", "prev", "\n", "if", "err", ":=", "ds", ".", "Get", "(", "c", ",", "&", "entity", ")", ";", "err", "!=", "nil", "&&", "err", "!=", "ds", ".", "ErrNoSuchEntity", "{", "return", "err", "\n", "}", "\n", "if", "entity", ".", "EntityVersion", "!=", "prev", ".", "EntityVersion", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ca", ".", "CN", ")", "\n", "}", "\n", "entity", ".", "EntityVersion", "++", "\n", "entity", ".", "LastUpdateTime", "=", "crl", ".", "TBSCertList", ".", "ThisUpdate", ".", "UTC", "(", ")", "\n", "entity", ".", "LastFetchTime", "=", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", "\n", "entity", ".", "LastFetchETag", "=", "etag", "\n", "entity", ".", "RevokedCertsCount", "=", "len", "(", "crl", ".", "TBSCertList", ".", "RevokedCertificates", ")", "\n\n", "updated", "=", "&", "entity", "// used outside of this function", "\n", "toPut", ":=", "[", "]", "interface", "{", "}", "{", "updated", "}", "\n\n", "// Mark CA entity as ready for usage.", "curCA", ":=", "CA", "{", "CN", ":", "ca", ".", "CN", "}", "\n", "switch", "err", ":=", "ds", ".", "Get", "(", "c", ",", "&", "curCA", ")", ";", "{", "case", "err", "==", "ds", ".", "ErrNoSuchEntity", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ca", ".", "CN", ")", "\n", "case", "err", "!=", "nil", ":", "return", "err", "\n", "}", "\n", "if", "!", "curCA", ".", "Ready", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "curCA", ".", "CN", ")", "\n", "curCA", ".", "Ready", "=", "true", "\n", "toPut", "=", "append", "(", "toPut", ",", "&", "curCA", ")", "\n", "}", "\n", "return", "ds", ".", "Put", "(", "c", ",", "toPut", ")", "\n", "}", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "ca", ".", "CN", ",", "updated", ".", "EntityVersion", ")", "\n", "return", "updated", ",", "nil", "\n", "}" ]

[ "validateAndStoreCRL", "handles", "incoming", "CRL", "blob", "fetched", "by", "fetchCRL", "." ]

[ "func", "NewFilesystemView", "(", "root", "string", ",", "blacklist", "[", "]", "string", ")", "(", "FilesystemView", ",", "error", ")", "{", "for", "_", ",", "b", ":=", "range", "blacklist", "{", "if", "_", ",", "err", ":=", "filepath", ".", "Match", "(", "b", ",", "b", ")", ";", "err", "!=", "nil", "{", "return", "FilesystemView", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ",", "b", ")", "\n", "}", "\n", "}", "\n", "return", "FilesystemView", "{", "root", ":", "root", ",", "blacklist", ":", "blacklist", "}", ",", "nil", "\n", "}" ]

[ "NewFilesystemView", "returns", "a", "FilesystemView", "based", "on", "the", "supplied", "root", "and", "blacklist", "or", "an", "error", "if", "blacklist", "contains", "a", "bad", "pattern", ".", "root", "is", "the", "the", "base", "path", "used", "by", "RelativePath", "to", "calulate", "relative", "paths", ".", "blacklist", "is", "a", "list", "of", "globs", "of", "files", "to", "ignore", ".", "See", "RelativePath", "for", "more", "information", "." ]

[ "func", "(", "ff", "FilesystemView", ")", "NewSymlinkedView", "(", "source", ",", "linkname", "string", ")", "FilesystemView", "{", "prefix", ":=", "source", "\n", "if", "ff", ".", "sourcePrefix", "!=", "\"", "\"", "{", "prefix", "=", "filepath", ".", "Join", "(", "ff", ".", "sourcePrefix", ",", "source", ")", "\n", "}", "\n", "return", "FilesystemView", "{", "root", ":", "linkname", ",", "blacklist", ":", "ff", ".", "blacklist", ",", "sourcePrefix", ":", "prefix", "}", "\n", "}" ]

[ "NewSymlinkedView", "returns", "a", "filesystem", "view", "from", "a", "symlinked", "directory", "within", "itself", "." ]

[ "func", "match", "(", "pattern", ",", "name", "string", ")", "bool", "{", "matched", ",", "_", ":=", "filepath", ".", "Match", "(", "pattern", ",", "name", ")", "\n", "return", "matched", "\n", "}" ]

[ "match", "is", "equivalent", "to", "filepath", ".", "Match", "but", "assumes", "that", "pattern", "is", "valid", "." ]

[ "func", "WalkFuncSkipFile", "(", "file", "os", ".", "FileInfo", ")", "error", "{", "if", "file", ".", "IsDir", "(", ")", "{", "return", "filepath", ".", "SkipDir", "\n", "}", "\n", "// If we were to return SkipDir for a file, it would cause", "// filepath.Walk to skip the file's containing directory, which we do", "// not want (see https://golang.org/pkg/path/filepath/#WalkFunc).", "return", "nil", "\n", "}" ]

[ "WalkFuncSkipFile", "is", "a", "helper", "for", "implemenations", "of", "filepath", ".", "WalkFunc", ".", "The", "value", "that", "it", "returns", "may", "in", "turn", "be", "returned", "by", "the", "WalkFunc", "implementaiton", "to", "indicate", "that", "file", "should", "be", "skipped", "." ]

[ "func", "IsLocalHost", "(", "hostport", "string", ")", "bool", "{", "host", ",", "_", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "hostport", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "switch", "{", "case", "host", "==", "\"", "\"", ",", "host", "==", "\"", "\"", ":", "case", "net", ".", "ParseIP", "(", "host", ")", ".", "IsLoopback", "(", ")", ":", "default", ":", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "IsLocalHost", "returns", "true", "if", "hostport", "is", "local", "." ]

[ "func", "(", "r", "*", "InspectMachineTokenRPC", ")", "InspectMachineToken", "(", "c", "context", ".", "Context", ",", "req", "*", "admin", ".", "InspectMachineTokenRequest", ")", "(", "*", "admin", ".", "InspectMachineTokenResponse", ",", "error", ")", "{", "// Defaults.", "if", "req", ".", "TokenType", "==", "0", "{", "req", ".", "TokenType", "=", "tokenserver", ".", "MachineTokenType_LUCI_MACHINE_TOKEN", "\n", "}", "\n\n", "// Only LUCI_MACHINE_TOKEN is supported currently.", "switch", "req", ".", "TokenType", "{", "case", "tokenserver", ".", "MachineTokenType_LUCI_MACHINE_TOKEN", ":", "// supported", "default", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "req", ".", "TokenType", ")", "\n", "}", "\n\n", "// Deserialize the token, check its signature.", "inspection", ",", "err", ":=", "InspectToken", "(", "c", ",", "r", ".", "Signer", ",", "req", ".", "Token", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "resp", ":=", "&", "admin", ".", "InspectMachineTokenResponse", "{", "Signed", ":", "inspection", ".", "Signed", ",", "NonExpired", ":", "inspection", ".", "NonExpired", ",", "InvalidityReason", ":", "inspection", ".", "InvalidityReason", ",", "}", "\n\n", "// Grab the signing key from the envelope, if managed to deserialize it.", "if", "env", ",", "_", ":=", "inspection", ".", "Envelope", ".", "(", "*", "tokenserver", ".", "MachineTokenEnvelope", ")", ";", "env", "!=", "nil", "{", "resp", ".", "SigningKeyId", "=", "env", ".", "KeyId", "\n", "}", "\n\n", "// If we could not deserialize the body, that's all checks we could do.", "body", ",", "_", ":=", "inspection", ".", "Body", ".", "(", "*", "tokenserver", ".", "MachineTokenBody", ")", "\n", "if", "body", "==", "nil", "{", "return", "resp", ",", "nil", "\n", "}", "\n", "resp", ".", "TokenType", "=", "&", "admin", ".", "InspectMachineTokenResponse_LuciMachineToken", "{", "LuciMachineToken", ":", "body", ",", "}", "\n\n", "addReason", ":=", "func", "(", "r", "string", ")", "{", "if", "resp", ".", "InvalidityReason", "==", "\"", "\"", "{", "resp", ".", "InvalidityReason", "=", "r", "\n", "}", "else", "{", "resp", ".", "InvalidityReason", "+=", "\"", "\"", "+", "r", "\n", "}", "\n", "}", "\n\n", "// Check revocation status. Find CA name that signed the certificate used when", "// minting the token.", "caName", ",", "err", ":=", "certconfig", ".", "GetCAByUniqueID", "(", "c", ",", "body", ".", "CaId", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "case", "caName", "==", "\"", "\"", ":", "addReason", "(", "\"", "\"", ")", "\n", "return", "resp", ",", "nil", "\n", "}", "\n", "resp", ".", "CertCaName", "=", "caName", "\n\n", "// Grab CertChecker for this CA. It has CRL cached.", "certChecker", ",", "err", ":=", "certchecker", ".", "GetCertChecker", "(", "c", ",", "caName", ")", "\n", "switch", "{", "case", "transient", ".", "Tag", ".", "In", "(", "err", ")", ":", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "case", "err", "!=", "nil", ":", "addReason", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "return", "resp", ",", "nil", "\n", "}", "\n\n", "// Check that certificate SN is not in the revocation list.", "sn", ":=", "big", ".", "NewInt", "(", "0", ")", ".", "SetUint64", "(", "body", ".", "CertSn", ")", "\n", "revoked", ",", "err", ":=", "certChecker", ".", "CRL", ".", "IsRevokedSN", "(", "c", ",", "sn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "resp", ".", "NonRevoked", "=", "!", "revoked", "\n\n", "// Note: if Signed or NonExpired is false, InvalidityReason is already set.", "if", "resp", ".", "Signed", "&&", "resp", ".", "NonExpired", "{", "if", "resp", ".", "NonRevoked", "{", "resp", ".", "Valid", "=", "true", "\n", "}", "else", "{", "addReason", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "InspectMachineToken", "decodes", "a", "machine", "token", "and", "verifies", "it", "is", "valid", "." ]

[ "func", "(", "s", "*", "State", ")", "clear", "(", ")", "{", "*", "s", "=", "State", "{", "Inputs", ":", "s", ".", "Inputs", ",", "vars", ":", "s", ".", "vars", "}", "\n", "s", ".", "vars", ".", "ClearValues", "(", ")", "\n", "}" ]

[ "clear", "resets", "the", "state", "." ]

[ "func", "(", "s", "*", "State", ")", "err", "(", "err", "...", "error", ")", "error", "{", "if", "s", ".", "seenErrs", "==", "nil", "{", "s", ".", "seenErrs", "=", "stringset", ".", "New", "(", "len", "(", "err", ")", ")", "\n", "}", "\n", "for", "_", ",", "e", ":=", "range", "err", "{", "if", "bt", ",", "_", ":=", "e", ".", "(", "BacktracableError", ")", ";", "bt", "==", "nil", "||", "s", ".", "seenErrs", ".", "Add", "(", "bt", ".", "Backtrace", "(", ")", ")", "{", "s", ".", "errors", "=", "append", "(", "s", ".", "errors", ",", "e", ")", "\n", "}", "\n", "}", "\n", "return", "s", ".", "errors", "\n", "}" ]

[ "err", "adds", "errors", "to", "the", "list", "of", "errors", "and", "returns", "the", "list", "as", "MultiError", "deduplicating", "errors", "with", "identical", "backtraces", "." ]

[ "func", "(", "r", "*", "CheckCertificateRPC", ")", "CheckCertificate", "(", "c", "context", ".", "Context", ",", "req", "*", "admin", ".", "CheckCertificateRequest", ")", "(", "*", "admin", ".", "CheckCertificateResponse", ",", "error", ")", "{", "// Deserialize the cert.", "der", ",", "err", ":=", "utils", ".", "ParsePEM", "(", "req", ".", "CertPem", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "cert", ",", "err", ":=", "x509", ".", "ParseCertificate", "(", "der", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Find a checker for the CA that signed the cert, check the certificate.", "checker", ",", "err", ":=", "GetCertChecker", "(", "c", ",", "cert", ".", "Issuer", ".", "CommonName", ")", "\n", "if", "err", "==", "nil", "{", "_", ",", "err", "=", "checker", ".", "CheckCertificate", "(", "c", ",", "cert", ")", "\n", "if", "err", "==", "nil", "{", "return", "&", "admin", ".", "CheckCertificateResponse", "{", "IsValid", ":", "true", ",", "}", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Recognize error codes related to CA cert checking. Everything else is", "// transient errors.", "if", "details", ",", "ok", ":=", "err", ".", "(", "Error", ")", ";", "ok", "{", "return", "&", "admin", ".", "CheckCertificateResponse", "{", "IsValid", ":", "false", ",", "InvalidReason", ":", "details", ".", "Error", "(", ")", ",", "}", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Internal", ",", "\"", "\"", ",", "err", ")", "\n", "}" ]

[ "CheckCertificate", "says", "whether", "a", "certificate", "is", "valid", "or", "not", "." ]

[ "func", "(", "s", "*", "sanitizer", ")", "p", "(", "safeMarkup", "string", ")", "{", "if", "s", ".", "err", "==", "nil", "{", "_", ",", "s", ".", "err", "=", "s", ".", "sw", ".", "WriteString", "(", "safeMarkup", ")", "\n", "}", "\n", "}" ]

[ "p", "prints", "the", "text", "unless", "there", "was", "an", "error", "before", "." ]

[ "func", "(", "s", "*", "sanitizer", ")", "printAttr", "(", "key", ",", "value", "string", ")", "{", "s", ".", "p", "(", "\"", "\"", ")", "\n", "s", ".", "p", "(", "key", ")", "\n", "s", ".", "p", "(", "\"", "\\\"", "\"", ")", "\n", "s", ".", "p", "(", "html", ".", "EscapeString", "(", "value", ")", ")", "\n", "s", ".", "p", "(", "\"", "\\\"", "\"", ")", "\n", "}" ]

[ "printAttr", "prints", "a", "space", "and", "then", "an", "HTML", "attribute", "node", "." ]

[ "func", "New", "(", "err", "error", ")", "backend", ".", "B", "{", "if", "err", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "erroringImpl", "{", "err", "}", "\n", "}" ]

[ "New", "produces", "backend", ".", "B", "instance", "that", "returns", "the", "given", "error", "for", "all", "calls", ".", "Panics", "if", "given", "err", "is", "nil", "." ]

[ "func", "NewLogStreamState", "(", "c", "context", ".", "Context", ",", "id", "HashID", ")", "*", "LogStreamState", "{", "return", "&", "LogStreamState", "{", "Parent", ":", "ds", ".", "NewKey", "(", "c", ",", "\"", "\"", ",", "string", "(", "id", ")", ",", "0", ",", "nil", ")", "}", "\n", "}" ]

[ "NewLogStreamState", "returns", "a", "LogStreamState", "with", "its", "parent", "key", "populated", "to", "the", "LogStream", "with", "the", "supplied", "ID", "." ]

[ "func", "(", "lst", "*", "LogStreamState", ")", "Validate", "(", ")", "error", "{", "if", "lst", ".", "Created", ".", "IsZero", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "lst", ".", "Updated", ".", "IsZero", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "lst", ".", "Terminated", "(", ")", "&&", "lst", ".", "TerminatedTime", ".", "IsZero", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "types", ".", "PrefixSecret", "(", "lst", ".", "Secret", ")", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "evaluates", "the", "state", "and", "data", "contents", "of", "the", "LogStreamState", "and", "returns", "an", "error", "if", "it", "is", "invalid", "." ]

[ "func", "(", "lst", "*", "LogStreamState", ")", "Terminated", "(", ")", "bool", "{", "if", "lst", ".", "ArchivalState", "(", ")", ".", "Archived", "(", ")", "{", "return", "true", "\n", "}", "\n", "return", "lst", ".", "TerminalIndex", ">=", "0", "\n", "}" ]

[ "Terminated", "returns", "true", "if", "this", "stream", "has", "been", "terminated", "." ]

[ "func", "(", "lst", "*", "LogStreamState", ")", "ArchivalState", "(", ")", "ArchivalState", "{", "if", "lst", ".", "ArchivedTime", ".", "IsZero", "(", ")", "{", "// Not archived, have we dispatched an archival?", "if", "len", "(", "lst", ".", "ArchivalKey", ")", ">", "0", "{", "return", "ArchiveTasked", "\n", "}", "\n", "return", "NotArchived", "\n", "}", "\n\n", "if", "lst", ".", "ArchiveLogEntryCount", ">", "lst", ".", "TerminalIndex", "{", "return", "ArchivedComplete", "\n", "}", "\n", "return", "ArchivedPartial", "\n", "}" ]

[ "ArchivalState", "returns", "the", "archival", "state", "of", "the", "log", "stream", "." ]

[ "func", "loadStateEntry", "(", "c", "context", ".", "Context", ",", "jobID", ",", "repo", "string", ")", "(", "*", "Repository", ",", "error", ")", "{", "id", ",", "err", ":=", "repositoryID", "(", "jobID", ",", "repo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "entry", ":=", "&", "Repository", "{", "ID", ":", "id", "}", "\n", "if", "err", ":=", "ds", ".", "Get", "(", "c", ",", "entry", ")", ";", "err", "==", "ds", ".", "ErrNoSuchEntity", "{", "return", "nil", ",", "err", "\n", "}", "else", "{", "return", "entry", ",", "transient", ".", "Tag", ".", "Apply", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "loadStateEntry", "loads", "Repository", "instance", "from", "datastore", "." ]

[ "func", "handleBuildbotBuild", "(", "c", "*", "router", ".", "Context", ")", "error", "{", "buildNum", ",", "err", ":=", "strconv", ".", "Atoi", "(", "c", ".", "Params", ".", "ByName", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "grpcutil", ".", "InvalidArgumentTag", ")", ".", "Err", "(", ")", "\n", "}", "\n", "id", ":=", "buildbotapi", ".", "BuildID", "{", "Master", ":", "c", ".", "Params", ".", "ByName", "(", "\"", "\"", ")", ",", "Builder", ":", "c", ".", "Params", ".", "ByName", "(", "\"", "\"", ")", ",", "Number", ":", "buildNum", ",", "}", "\n", "if", "err", ":=", "id", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// If this build is emulated, redirect to LUCI.", "b", ",", "err", ":=", "buildstore", ".", "EmulationOf", "(", "c", ".", "Context", ",", "id", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "return", "err", "\n", "case", "b", "!=", "nil", "&&", "b", ".", "Number", "!=", "nil", ":", "u", ":=", "*", "c", ".", "Request", ".", "URL", "\n", "u", ".", "Path", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Project", ",", "b", ".", "Bucket", ",", "b", ".", "Builder", ",", "*", "b", ".", "Number", ")", "\n", "http", ".", "Redirect", "(", "c", ".", "Writer", ",", "c", ".", "Request", ",", "u", ".", "String", "(", ")", ",", "http", ".", "StatusFound", ")", "\n", "return", "nil", "\n", "default", ":", "build", ",", "err", ":=", "buildbot", ".", "GetBuild", "(", "c", ".", "Context", ",", "id", ")", "\n", "return", "renderBuildLegacy", "(", "c", ",", "build", ",", "false", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "handleBuildbotBuild", "renders", "a", "buildbot", "build", ".", "Requires", "emulationMiddleware", "." ]

[ "func", "handleLUCIBuildLegacy", "(", "c", "*", "router", ".", "Context", ",", "bucket", ",", "builder", ",", "numberOrId", "string", ")", "error", "{", "var", "address", "string", "\n", "if", "strings", ".", "HasPrefix", "(", "numberOrId", ",", "\"", "\"", ")", "{", "address", "=", "numberOrId", "[", "1", ":", "]", "\n", "}", "else", "{", "address", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "bucket", ",", "builder", ",", "numberOrId", ")", "\n", "}", "\n\n", "build", ",", "err", ":=", "buildbucket", ".", "GetBuildLegacy", "(", "c", ".", "Context", ",", "address", ",", "true", ")", "\n", "return", "renderBuildLegacy", "(", "c", ",", "build", ",", "true", ",", "err", ")", "\n", "}" ]

[ "handleLUCIBuildLegacy", "renders", "a", "LUCI", "build", "." ]

[ "func", "makeFeedbackLink", "(", "c", "*", "router", ".", "Context", ",", "build", "*", "ui", ".", "MiloBuildLegacy", ")", "string", "{", "project", ",", "err", ":=", "common", ".", "GetProject", "(", "c", ".", "Context", ",", "c", ".", "Params", ".", "ByName", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "||", "proto", ".", "Equal", "(", "&", "project", ".", "BuildBugTemplate", ",", "&", "config", ".", "BugTemplate", "{", "}", ")", "{", "return", "\"", "\"", "\n", "}", "\n\n", "buildURL", ":=", "c", ".", "Request", ".", "URL", "\n", "var", "builderURL", "*", "url", ".", "URL", "\n", "if", "build", ".", "Summary", ".", "ParentLabel", "!=", "nil", "&&", "build", ".", "Summary", ".", "ParentLabel", ".", "URL", "!=", "\"", "\"", "{", "builderURL", ",", "err", "=", "buildURL", ".", "Parse", "(", "build", ".", "Summary", ".", "ParentLabel", ".", "URL", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ".", "Context", ",", "\"", "\"", ")", "\n", "return", "\"", "\"", "\n", "}", "\n", "}", "\n\n", "link", ",", "err", ":=", "buildbucket", ".", "MakeBuildBugLink", "(", "&", "project", ".", "BuildBugTemplate", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "makeBuild", "(", "c", ".", "Params", ",", "build", ")", ",", "\"", "\"", ":", "buildURL", ",", "\"", "\"", ":", "builderURL", ",", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ".", "Context", ",", "\"", "\"", ")", "\n", "return", "\"", "\"", "\n", "}", "\n\n", "return", "link", "\n", "}" ]

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

[ "func", "makeBuild", "(", "params", "httprouter", ".", "Params", ",", "build", "*", "ui", ".", "MiloBuildLegacy", ")", "*", "buildbucketpb", ".", "Build", "{", "return", "&", "buildbucketpb", ".", "Build", "{", "Builder", ":", "&", "buildbucketpb", ".", "BuilderID", "{", "Project", ":", "build", ".", "Trigger", ".", "Project", ",", "// equivalent params.ByName(\"project\")", "Bucket", ":", "params", ".", "ByName", "(", "\"", "\"", ")", ",", "// way to get from ui.MiloBuildLegacy so don't need params here?", "Builder", ":", "build", ".", "Summary", ".", "ParentLabel", ".", "Label", ",", "// params.ByName(\"builder\")", "}", ",", "}", "\n", "}" ]

[ "makeBuild", "partially", "populates", "a", "buildbucketpb", ".", "Build", ".", "Currently", "it", "attempts", "to", "make", "available", ".", "Builder", ".", "Project", ".", "Builder", ".", "Bucket", "and", ".", "Builder", ".", "Builder", "." ]

[ "func", "(", "k", "*", "Key", ")", "Less", "(", "an", "*", "Key", ")", "bool", "{", "return", "k", ".", "cmp", "<", "an", ".", "cmp", "\n", "}" ]

[ "Less", "returns", "true", "if", "this", "key", "is", "lexicographically", "before", "another", "key", "." ]