Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "defaultSigner", "(", "c", "context", ".", "Context", ")", "(", "*", "signer", ",", "error", ")", "{", "s", ":=", "auth", ".", "GetSigner", "(", "c", ")", "\n", "if", "s", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "info", ",", "err", ":=", "s", ".", "ServiceInfo", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "&", "signer", "{", "Email", ":", "info", ".", "ServiceAccountName", ",", "SignBytes", ":", "s", ".", "SignBytes", ",", "}", ",", "nil", "\n", "}" ]

[ "defaultSigner", "uses", "the", "default", "app", "account", "for", "signing", "." ]

[ "func", "iamSigner", "(", "c", "context", ".", "Context", ",", "actAs", "string", ")", "(", "*", "signer", ",", "error", ")", "{", "t", ",", "err", ":=", "auth", ".", "GetRPCTransport", "(", "c", ",", "auth", ".", "AsSelf", ",", "auth", ".", "WithScopes", "(", "iam", ".", "OAuthScope", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "s", ":=", "&", "iam", ".", "Signer", "{", "Client", ":", "&", "iam", ".", "Client", "{", "Client", ":", "&", "http", ".", "Client", "{", "Transport", ":", "t", "}", "}", ",", "ServiceAccount", ":", "actAs", ",", "}", "\n", "return", "&", "signer", "{", "Email", ":", "actAs", ",", "SignBytes", ":", "s", ".", "SignBytes", ",", "}", ",", "nil", "\n", "}" ]

[ "iamSigner", "uses", "SignBytes", "IAM", "API", "for", "signing", "." ]

[ "func", "(", "a", "*", "AttemptList", ")", "Normalize", "(", ")", "error", "{", "for", "q", ",", "vals", ":=", "range", "a", ".", "GetTo", "(", ")", "{", "if", "vals", "==", "nil", "{", "a", ".", "To", "[", "q", "]", "=", "&", "AttemptList_Nums", "{", "}", "\n", "}", "else", "{", "if", "err", ":=", "vals", ".", "Normalize", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "sorts", "and", "uniq", "s", "attempt", "nums" ]

[ "func", "(", "a", "*", "AttemptList", ")", "AddAIDs", "(", "aids", "...", "*", "Attempt_ID", ")", "{", "for", "_", ",", "aid", ":=", "range", "aids", "{", "if", "a", ".", "To", "==", "nil", "{", "a", ".", "To", "=", "map", "[", "string", "]", "*", "AttemptList_Nums", "{", "}", "\n", "}", "\n", "atmptNums", ":=", "a", ".", "To", "[", "aid", ".", "Quest", "]", "\n", "if", "atmptNums", "==", "nil", "{", "atmptNums", "=", "&", "AttemptList_Nums", "{", "}", "\n", "a", ".", "To", "[", "aid", ".", "Quest", "]", "=", "atmptNums", "\n", "}", "\n", "atmptNums", ".", "Nums", "=", "append", "(", "atmptNums", ".", "Nums", ",", "aid", ".", "Id", ")", "\n", "}", "\n", "}" ]

[ "AddAIDs", "adds", "the", "given", "Attempt_ID", "to", "the", "AttemptList" ]

[ "func", "(", "a", "*", "AttemptList", ")", "Dup", "(", ")", "*", "AttemptList", "{", "ret", ":=", "&", "AttemptList", "{", "}", "\n", "for", "k", ",", "v", ":=", "range", "a", ".", "To", "{", "if", "ret", ".", "To", "==", "nil", "{", "ret", ".", "To", "=", "make", "(", "map", "[", "string", "]", "*", "AttemptList_Nums", ",", "len", "(", "a", ".", "To", ")", ")", "\n", "}", "\n", "vals", ":=", "&", "AttemptList_Nums", "{", "Nums", ":", "make", "(", "[", "]", "uint32", ",", "len", "(", "v", ".", "Nums", ")", ")", "}", "\n", "copy", "(", "vals", ".", "Nums", ",", "v", ".", "Nums", ")", "\n", "ret", ".", "To", "[", "k", "]", "=", "vals", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "Dup", "does", "a", "deep", "copy", "of", "this", "AttemptList", "." ]

[ "func", "(", "a", "*", "AttemptList", ")", "UpdateWith", "(", "o", "*", "AttemptList", ")", "{", "for", "qid", ",", "atmpts", ":=", "range", "o", ".", "To", "{", "if", "curAtmpts", ",", "ok", ":=", "a", ".", "To", "[", "qid", "]", ";", "!", "ok", "{", "a", ".", "To", "[", "qid", "]", "=", "atmpts", "\n", "}", "else", "{", "curAtmpts", ".", "Nums", "=", "append", "(", "curAtmpts", ".", "Nums", ",", "atmpts", ".", "Nums", "...", ")", "\n", "curAtmpts", ".", "Normalize", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "UpdateWith", "updates", "this", "AttemptList", "with", "all", "the", "entries", "in", "the", "other", "AttemptList", "." ]

[ "func", "(", "def", "*", "PackageDef", ")", "VersionFile", "(", ")", "string", "{", "// It is already validated by LoadPackageDef, so just return it.", "for", "_", ",", "chunk", ":=", "range", "def", ".", "Data", "{", "if", "chunk", ".", "VersionFile", "!=", "\"", "\"", "{", "return", "chunk", ".", "VersionFile", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "VersionFile", "defines", "where", "to", "drop", "JSON", "file", "with", "package", "version", "." ]

[ "func", "makeExclusionFilter", "(", "startDir", "string", ",", "patterns", "[", "]", "string", ")", "(", "fs", ".", "ScanFilter", ",", "error", ")", "{", "if", "len", "(", "patterns", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// Compile regular expressions.", "exps", ":=", "[", "]", "*", "regexp", ".", "Regexp", "{", "}", "\n", "for", "_", ",", "expr", ":=", "range", "patterns", "{", "if", "expr", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "if", "expr", "[", "0", "]", "!=", "'^'", "{", "expr", "=", "\"", "\"", "+", "expr", "\n", "}", "\n", "if", "expr", "[", "len", "(", "expr", ")", "-", "1", "]", "!=", "'$'", "{", "expr", "=", "expr", "+", "\"", "\"", "\n", "}", "\n", "re", ",", "err", ":=", "regexp", ".", "Compile", "(", "expr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "exps", "=", "append", "(", "exps", ",", "re", ")", "\n", "}", "\n\n", "return", "func", "(", "abs", "string", ")", "bool", "{", "rel", ",", "err", ":=", "filepath", ".", "Rel", "(", "startDir", ",", "abs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "true", "\n", "}", "\n", "// Do not evaluate paths outside of startDir or startDir itself.", "rel", "=", "filepath", ".", "ToSlash", "(", "rel", ")", "\n", "if", "rel", "==", "\"", "\"", "||", "strings", ".", "HasPrefix", "(", "rel", ",", "\"", "\"", ")", "{", "return", "false", "\n", "}", "\n", "for", "_", ",", "exp", ":=", "range", "exps", "{", "if", "exp", ".", "MatchString", "(", "rel", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", ",", "nil", "\n", "}" ]

[ "makeExclusionFilter", "produces", "a", "predicate", "that", "checks", "an", "absolute", "file", "path", "against", "a", "list", "of", "regexps", ".", "Regexps", "are", "defined", "against", "slash", "separated", "paths", "relative", "to", "startDir", ".", "The", "predicate", "takes", "absolute", "native", "path", "converts", "it", "to", "slash", "separated", "path", "relative", "to", "startDir", "and", "checks", "against", "list", "of", "regexps", "in", "patterns", ".", "Returns", "true", "to", "exclude", "a", "path", "." ]

[ "func", "WithState", "(", "c", "context", ".", "Context", ",", "s", "State", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "c", ",", "stateContextKey", "(", "0", ")", ",", "s", ")", "\n", "}" ]

[ "WithState", "injects", "State", "into", "the", "context", ".", "Mostly", "useful", "from", "tests", ".", "Must", "not", "be", "normally", "used", "from", "production", "code", "Authenticate", "sets", "the", "state", "itself", "." ]

[ "func", "(", "r", "*", "cmdRun", ")", "done", "(", "err", "error", ")", "int", "{", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "err", ")", "\n", "if", "err", ",", "ok", ":=", "err", ".", "(", "*", "exitCode", ")", ";", "ok", "{", "return", "err", ".", "code", "\n", "}", "\n", "return", "ecOtherError", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "done", "prints", "err", "to", "stderr", "if", "it", "is", "not", "nil", "and", "returns", "an", "exit", "code", "." ]

[ "func", "PagingLog", "(", "ctx", "context", ".", "Context", ",", "client", "gitiles", ".", "GitilesClient", ",", "req", "gitiles", ".", "LogRequest", ",", "limit", "int", ",", "opts", "...", "grpc", ".", "CallOption", ")", "(", "[", "]", "*", "git", ".", "Commit", ",", "error", ")", "{", "// Note: we intentionally receive req as struct (not pointer)", "// because we need to mutate it.", "switch", "{", "case", "limit", "<", "0", ":", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "limit", "==", "0", ":", "limit", "=", "DefaultLimit", "\n", "}", "\n\n", "var", "combinedLog", "[", "]", "*", "git", ".", "Commit", "\n", "for", "{", "remaining", ":=", "limit", "-", "len", "(", "combinedLog", ")", "\n", "if", "remaining", "<=", "0", "{", "break", "\n", "}", "\n", "if", "req", ".", "PageSize", "==", "0", "||", "remaining", "<", "int", "(", "req", ".", "PageSize", ")", "{", "// Do not fetch more than we need.", "req", ".", "PageSize", "=", "int32", "(", "remaining", ")", "\n", "}", "\n\n", "res", ",", "err", ":=", "client", ".", "Log", "(", "ctx", ",", "&", "req", ",", "opts", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "combinedLog", ",", "err", "\n", "}", "\n\n", "// req was capped, so this should not exceed limit.", "combinedLog", "=", "append", "(", "combinedLog", ",", "res", ".", "Log", "...", ")", "\n", "// There may be fewer commits in the log than the limit given,", "// if so, NextPageToken should be missing.", "if", "res", ".", "NextPageToken", "==", "\"", "\"", "{", "break", "\n", "}", "\n", "req", ".", "PageToken", "=", "res", ".", "NextPageToken", "\n", "}", "\n", "return", "combinedLog", ",", "nil", "\n", "}" ]

[ "Helper", "functions", "for", "Gitiles", ".", "Log", "RPC", ".", "PagingLog", "is", "a", "wrapper", "around", "Gitiles", ".", "Log", "RPC", "that", "pages", "though", "commits", ".", "If", "req", ".", "PageToken", "is", "not", "empty", "paging", "will", "continue", "from", "there", ".", "req", ".", "PageSize", "specifies", "maximum", "number", "of", "commits", "to", "load", "in", "each", "page", ".", "Limit", "specifies", "the", "maximum", "number", "of", "commits", "to", "load", ".", "0", "means", "use", "DefaultLimit", "." ]

[ "func", "(", "r", "Result", ")", "Status", "(", ")", "model", ".", "Status", "{", "switch", "r", "{", "case", "NoResult", ":", "return", "model", ".", "Running", "\n", "case", "Success", ":", "return", "model", ".", "Success", "\n", "case", "Warning", ":", "return", "model", ".", "Warning", "\n", "case", "Failure", ":", "return", "model", ".", "Failure", "\n", "case", "Skipped", ":", "return", "model", ".", "NotRun", "\n", "case", "Exception", ",", "Retry", ":", "return", "model", ".", "Exception", "\n", "default", ":", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", ")", "\n", "}", "\n", "}" ]

[ "Status", "converts", "r", "into", "a", "model", ".", "Status", "." ]

[ "func", "(", "e", "Enum", ")", "GetKey", "(", "value", "interface", "{", "}", ")", "string", "{", "for", "k", ",", "v", ":=", "range", "e", "{", "if", "reflect", ".", "DeepEqual", "(", "v", ",", "value", ")", "{", "return", "k", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "GetKey", "performs", "reverse", "lookup", "of", "the", "enumeration", "value", "returning", "the", "key", "that", "corresponds", "to", "the", "value", ".", "If", "multiple", "keys", "correspond", "to", "the", "same", "value", "the", "result", "is", "undefined", "." ]

[ "func", "(", "e", "Enum", ")", "GetValue", "(", "key", "string", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "for", "k", ",", "v", ":=", "range", "e", "{", "if", "k", "==", "key", "{", "return", "v", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "Choices", "(", ")", ")", "\n", "}" ]

[ "GetValue", "returns", "the", "mapped", "enumeration", "value", "associated", "with", "a", "key", "." ]

[ "func", "(", "e", "Enum", ")", "Choices", "(", ")", "string", "{", "keys", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "e", ")", ")", "\n", "for", "k", ":=", "range", "e", "{", "if", "k", "==", "\"", "\"", "{", "k", "=", "`\"\"`", "\n", "}", "\n", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n", "return", "strings", ".", "Join", "(", "keys", ",", "\"", "\"", ")", "\n", "}" ]

[ "Choices", "returns", "a", "comma", "-", "separated", "string", "listing", "sorted", "enumeration", "choices", "." ]

[ "func", "(", "e", "Enum", ")", "setValue", "(", "v", "interface", "{", "}", ",", "key", "string", ")", "error", "{", "i", ",", "err", ":=", "e", ".", "GetValue", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "vValue", ":=", "reflect", ".", "ValueOf", "(", "v", ")", ".", "Elem", "(", ")", "\n", "if", "!", "vValue", ".", "CanSet", "(", ")", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "vValue", ")", ")", "\n", "}", "\n\n", "iValue", ":=", "reflect", ".", "ValueOf", "(", "i", ")", "\n", "if", "!", "vValue", ".", "Type", "(", ")", ".", "AssignableTo", "(", "iValue", ".", "Type", "(", ")", ")", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "vValue", ".", "Type", "(", ")", ",", "iValue", ".", "Type", "(", ")", ")", ")", "\n", "}", "\n\n", "vValue", ".", "Set", "(", "iValue", ")", "\n", "return", "nil", "\n", "}" ]

[ "Sets", "the", "value", "v", "to", "the", "enumeration", "value", "mapped", "to", "the", "supplied", "key", "." ]

[ "func", "(", "e", "Enum", ")", "FlagSet", "(", "v", "interface", "{", "}", ",", "key", "string", ")", "error", "{", "return", "e", ".", "setValue", "(", "v", ",", "key", ")", "\n", "}" ]

[ "FlagSet", "implements", "flag", ".", "Value", "s", "Set", "semantics", ".", "It", "identifies", "the", "mapped", "value", "associated", "with", "the", "supplied", "key", "and", "stores", "it", "in", "the", "supplied", "interface", ".", "The", "interface", "v", "must", "be", "a", "valid", "pointer", "to", "the", "mapped", "enumeration", "type", "." ]

[ "func", "(", "e", "Enum", ")", "JSONUnmarshal", "(", "v", "interface", "{", "}", ",", "data", "[", "]", "byte", ")", "error", "{", "s", ":=", "\"", "\"", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "data", ",", "&", "s", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "e", ".", "FlagSet", "(", "v", ",", "s", ")", "\n", "}" ]

[ "JSONUnmarshal", "implements", "json", ".", "Unmarshaler", "s", "UnmarshalJSON", "semantics", ".", "It", "parses", "data", "containing", "a", "quoted", "string", "identifies", "the", "enumeration", "value", "associated", "with", "that", "string", "and", "stores", "it", "in", "the", "supplied", "interface", ".", "The", "interface", "v", "must", "be", "a", "valid", "pointer", "to", "the", "mapped", "enumeration", "type", ".", "a", "string", "corresponding", "to", "one", "of", "the", "enum", "s", "keys", "." ]

[ "func", "(", "e", "Enum", ")", "JSONMarshal", "(", "v", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "key", ":=", "e", ".", "GetKey", "(", "v", ")", "\n", "data", ",", "err", ":=", "json", ".", "Marshal", "(", "&", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "data", ",", "nil", "\n", "}" ]

[ "JSONMarshal", "implements", "json", ".", "Marshaler", "s", "MarshalJSON", "semantics", ".", "It", "marshals", "the", "value", "in", "the", "supplied", "interface", "to", "its", "associated", "key", "and", "emits", "a", "quoted", "string", "containing", "that", "key", ".", "The", "interface", "v", "must", "be", "a", "valid", "pointer", "to", "the", "mapped", "enumeration", "type", "." ]

[ "func", "newNamedPipeClient", "(", "path", "string", ",", "ns", "types", ".", "StreamName", ")", "(", "Client", ",", "error", ")", "{", "if", "path", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "clientImpl", "{", "factory", ":", "func", "(", ")", "(", "io", ".", "WriteCloser", ",", "error", ")", "{", "return", "winio", ".", "DialPipe", "(", "LocalNamedPipePath", "(", "path", ")", ",", "nil", ")", "\n", "}", ",", "ns", ":", "ns", ",", "}", ",", "nil", "\n", "}" ]

[ "newNamedPipeClient", "creates", "a", "new", "Client", "instance", "bound", "to", "a", "named", "pipe", "stream", "server", "." ]

[ "func", "statusFromErrs", "(", "errs", "[", "]", "error", ")", "int", "{", "for", "_", ",", "err", ":=", "range", "errs", "{", "if", "grpc", ".", "Code", "(", "err", ")", "==", "codes", ".", "Internal", "{", "return", "http", ".", "StatusInternalServerError", "\n", "}", "\n", "}", "\n", "return", "http", ".", "StatusOK", "\n", "}" ]

[ "statusFromErrs", "returns", "500", "if", "any", "of", "gRPC", "errors", "is", "codes", ".", "Internal", "." ]

[ "func", "getBanner", "(", "c", "context", ".", "Context", ",", "b", "*", "buildbot", ".", "Build", ")", "*", "ui", ".", "LogoBanner", "{", "osLogo", ":=", "func", "(", ")", "*", "ui", ".", "Logo", "{", "result", ":=", "&", "ui", ".", "Logo", "{", "}", "\n", "switch", "b", ".", "OSFamily", "{", "case", "\"", "\"", ":", "result", ".", "LogoBase", "=", "ui", ".", "Windows", "\n", "case", "\"", "\"", ":", "result", ".", "LogoBase", "=", "ui", ".", "OSX", "\n", "case", "\"", "\"", ":", "result", ".", "LogoBase", "=", "ui", ".", "Ubuntu", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "result", ".", "Subtitle", "=", "b", ".", "OSVersion", "\n", "return", "result", "\n", "}", "(", ")", "\n", "if", "osLogo", "!=", "nil", "{", "return", "&", "ui", ".", "LogoBanner", "{", "OS", ":", "[", "]", "ui", ".", "Logo", "{", "*", "osLogo", "}", ",", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "getBanner", "parses", "the", "OS", "information", "from", "the", "build", "and", "maybe", "returns", "a", "banner", "." ]

[ "func", "summary", "(", "c", "context", ".", "Context", ",", "b", "*", "buildbot", ".", "Build", ")", "ui", ".", "BuildComponent", "{", "// TODO(hinoka): use b.toStatus()", "// Status", "var", "status", "model", ".", "Status", "\n", "if", "b", ".", "Currentstep", "!=", "nil", "{", "status", "=", "model", ".", "Running", "\n", "}", "else", "{", "status", "=", "b", ".", "Results", ".", "Status", "(", ")", "\n", "}", "\n\n", "// Link to bot and original build.", "host", ":=", "\"", "\"", "\n", "if", "b", ".", "Internal", "{", "host", "=", "\"", "\"", "\n", "}", "\n", "bot", ":=", "ui", ".", "NewLink", "(", "b", ".", "Slave", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "host", ",", "b", ".", "Master", ",", "b", ".", "Slave", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Slave", ")", ")", "\n\n", "var", "source", "*", "ui", ".", "Link", "\n", "if", "!", "b", ".", "Emulated", "{", "source", "=", "ui", ".", "NewLink", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Master", ",", "b", ".", "Buildername", ",", "b", ".", "Number", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "host", ",", "b", ".", "Master", ",", "b", ".", "Buildername", ",", "b", ".", "Number", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Number", ",", "b", ".", "Master", ",", "b", ".", "Buildername", ")", ")", "\n", "}", "\n\n", "// The link to this page and the builder page.", "label", ":=", "ui", ".", "NewLink", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Number", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Master", ",", "b", ".", "Buildername", ",", "b", ".", "Number", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Number", ",", "b", ".", "Master", ",", "b", ".", "Buildername", ")", ")", "\n", "// Perpetuate emulation mode, if it is currently on.", "if", "buildstore", ".", "EmulationEnabled", "(", "c", ")", "{", "label", ".", "URL", "+=", "\"", "\"", "\n", "}", "\n", "parent", ":=", "ui", ".", "NewLink", "(", "b", ".", "Buildername", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Buildername", ")", ")", "\n\n", "// Do a best effort lookup for the bot information to fill in OS/Platform info.", "banner", ":=", "getBanner", "(", "c", ",", "b", ")", "\n\n", "sum", ":=", "ui", ".", "BuildComponent", "{", "ParentLabel", ":", "parent", ",", "Label", ":", "label", ",", "Banner", ":", "banner", ",", "Status", ":", "status", ",", "ExecutionTime", ":", "ui", ".", "NewInterval", "(", "c", ",", "b", ".", "Times", ".", "Start", ".", "Time", ",", "b", ".", "Times", ".", "Finish", ".", "Time", ")", ",", "Bot", ":", "bot", ",", "Source", ":", "source", ",", "Type", ":", "ui", ".", "Summary", ",", "// This is more or less ignored.", "Text", ":", "mergeText", "(", "b", ".", "Text", ")", ",", "// Status messages. Eg \"This build failed on..xyz\"", "}", "\n\n", "return", "sum", "\n", "}" ]

[ "summary", "extracts", "the", "top", "level", "summary", "from", "a", "buildbot", "build", "as", "a", "BuildComponent" ]

[ "func", "parseProp", "(", "v", "interface", "{", "}", ")", "string", "{", "// if v is a whole number, force it into an int. json.Marshal() would turn", "// it into what looks like a float instead. We want this to remain and", "// int instead of a number.", "if", "vf", ",", "ok", ":=", "v", ".", "(", "float64", ")", ";", "ok", "{", "if", "math", ".", "Floor", "(", "vf", ")", "==", "vf", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int64", "(", "vf", ")", ")", "\n", "}", "\n", "}", "\n", "// return the json representation of the value.", "b", ",", "err", ":=", "json", ".", "Marshal", "(", "v", ")", "\n", "if", "err", "==", "nil", "{", "return", "string", "(", "b", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ")", "\n", "}" ]

[ "parseProp", "returns", "a", "string", "representation", "of", "v", "." ]

[ "func", "properties", "(", "b", "*", "buildbot", ".", "Build", ")", "(", "result", "[", "]", "*", "ui", ".", "PropertyGroup", ")", "{", "groups", ":=", "map", "[", "string", "]", "*", "ui", ".", "PropertyGroup", "{", "}", "\n", "allProps", ":=", "map", "[", "string", "]", "Prop", "{", "}", "\n", "for", "_", ",", "prop", ":=", "range", "b", ".", "Properties", "{", "allProps", "[", "prop", ".", "Name", "]", "=", "Prop", "{", "Value", ":", "prop", ".", "Value", ",", "Group", ":", "prop", ".", "Source", ",", "}", "\n", "}", "\n", "for", "key", ",", "prop", ":=", "range", "allProps", "{", "value", ":=", "prop", ".", "Value", "\n", "groupName", ":=", "prop", ".", "Group", "\n", "if", "_", ",", "ok", ":=", "groups", "[", "groupName", "]", ";", "!", "ok", "{", "groups", "[", "groupName", "]", "=", "&", "ui", ".", "PropertyGroup", "{", "GroupName", ":", "groupName", "}", "\n", "}", "\n", "vs", ":=", "parseProp", "(", "value", ")", "\n", "groups", "[", "groupName", "]", ".", "Property", "=", "append", "(", "groups", "[", "groupName", "]", ".", "Property", ",", "&", "ui", ".", "Property", "{", "Key", ":", "key", ",", "Value", ":", "vs", ",", "}", ")", "\n", "}", "\n", "// Insert the groups into a list in alphabetical order.", "// You have to make a separate sorting data structure because Go doesn't like", "// sorting things for you.", "groupNames", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "groups", ")", ")", "\n", "for", "n", ":=", "range", "groups", "{", "groupNames", "=", "append", "(", "groupNames", ",", "n", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "groupNames", ")", "\n", "for", "_", ",", "k", ":=", "range", "groupNames", "{", "group", ":=", "groups", "[", "k", "]", "\n", "// Also take this oppertunity to sort the properties within the groups.", "sort", ".", "Sort", "(", "group", ")", "\n", "result", "=", "append", "(", "result", ",", "group", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "properties", "extracts", "all", "properties", "from", "buildbot", "builds", "and", "groups", "them", "into", "property", "groups", "." ]

[ "func", "blame", "(", "b", "*", "buildbot", ".", "Build", ")", "(", "result", "[", "]", "*", "ui", ".", "Commit", ")", "{", "if", "b", ".", "Sourcestamp", "!=", "nil", "{", "for", "_", ",", "c", ":=", "range", "b", ".", "Sourcestamp", ".", "Changes", "{", "files", ":=", "c", ".", "GetFiles", "(", ")", "\n", "result", "=", "append", "(", "result", ",", "&", "ui", ".", "Commit", "{", "AuthorEmail", ":", "c", ".", "Who", ",", "Repo", ":", "c", ".", "Repository", ",", "CommitTime", ":", "time", ".", "Unix", "(", "int64", "(", "c", ".", "When", ")", ",", "0", ")", ".", "UTC", "(", ")", ",", "Revision", ":", "ui", ".", "NewLink", "(", "c", ".", "Revision", ",", "c", ".", "Revlink", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Who", ")", ")", ",", "Description", ":", "c", ".", "Comments", ",", "File", ":", "files", ",", "}", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "blame", "extracts", "the", "commit", "and", "blame", "information", "from", "a", "buildbot", "build", "and", "returns", "it", "as", "a", "list", "of", "Commits", "." ]

[ "func", "sourcestamp", "(", "c", "context", ".", "Context", ",", "b", "*", "buildbot", ".", "Build", ")", "*", "ui", ".", "Trigger", "{", "ss", ":=", "&", "ui", ".", "Trigger", "{", "}", "\n", "var", "rietveld", "url", ".", "URL", "\n", "var", "gerrit", "url", ".", "URL", "\n", "gotRevision", ":=", "\"", "\"", "\n", "repository", ":=", "\"", "\"", "\n", "issue", ":=", "int64", "(", "-", "1", ")", "\n", "patchset", ":=", "int64", "(", "-", "1", ")", "\n\n", "for", "_", ",", "prop", ":=", "range", "b", ".", "Properties", "{", "setIfIntOrStr", ":=", "func", "(", "dst", "*", "int64", ")", "{", "switch", "v", ":=", "prop", ".", "Value", ".", "(", "type", ")", "{", "case", "float64", ":", "*", "dst", "=", "int64", "(", "v", ")", "\n", "case", "string", ":", "if", "v", "!=", "\"", "\"", "{", "if", "vi", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "v", ",", "10", ",", "64", ")", ";", "err", "==", "nil", "{", "*", "dst", "=", "int64", "(", "vi", ")", "\n", "}", "else", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "prop", ".", "Name", ",", "v", ",", "err", ")", "\n", "}", "\n", "}", "\n", "default", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "prop", ".", "Name", ",", "v", ")", "\n", "}", "\n", "}", "\n", "setIfStr", ":=", "func", "(", "dst", "*", "string", ")", "{", "if", "v", ",", "ok", ":=", "prop", ".", "Value", ".", "(", "string", ")", ";", "ok", "{", "*", "dst", "=", "v", "\n", "}", "else", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "prop", ".", "Name", ",", "prop", ".", "Value", ")", "\n", "}", "\n", "}", "\n", "setIfURL", ":=", "func", "(", "dst", "*", "url", ".", "URL", ")", "{", "if", "v", ",", "ok", ":=", "prop", ".", "Value", ".", "(", "string", ")", ";", "ok", "{", "if", "u", ",", "err", ":=", "url", ".", "Parse", "(", "v", ")", ";", "err", "==", "nil", "{", "*", "dst", "=", "*", "u", "\n", "return", "\n", "}", "\n", "}", "\n", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "prop", ".", "Name", ",", "prop", ".", "Value", ")", "\n", "}", "\n\n", "switch", "prop", ".", "Name", "{", "case", "\"", "\"", ":", "setIfURL", "(", "&", "rietveld", ")", "\n", "case", "\"", "\"", ",", "\"", "\"", ":", "setIfIntOrStr", "(", "&", "issue", ")", "\n", "case", "\"", "\"", ":", "setIfStr", "(", "&", "gotRevision", ")", "\n", "case", "\"", "\"", ":", "setIfURL", "(", "&", "gerrit", ")", "\n", "case", "\"", "\"", ",", "\"", "\"", ":", "setIfIntOrStr", "(", "&", "patchset", ")", "\n", "case", "\"", "\"", ":", "setIfStr", "(", "&", "repository", ")", "\n", "}", "\n", "}", "\n", "if", "gerrit", ".", "Host", "!=", "\"", "\"", "&&", "issue", "!=", "-", "1", "&&", "patchset", "!=", "-", "1", "{", "cl", ":=", "&", "buildbucketpb", ".", "GerritChange", "{", "Host", ":", "gerrit", ".", "Host", ",", "Change", ":", "issue", ",", "Patchset", ":", "patchset", ",", "}", "\n", "ss", ".", "Changelist", "=", "ui", ".", "NewPatchLink", "(", "cl", ")", "\n", "}", "\n\n", "if", "gotRevision", "!=", "\"", "\"", "{", "ss", ".", "Revision", "=", "ui", ".", "NewLink", "(", "gotRevision", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "gotRevision", ")", ")", "\n", "if", "repository", "!=", "\"", "\"", "{", "ss", ".", "Revision", ".", "URL", "=", "repository", "+", "\"", "\"", "+", "gotRevision", "\n", "}", "\n", "}", "\n", "return", "ss", "\n", "}" ]

[ "sourcestamp", "extracts", "the", "source", "stamp", "from", "various", "parts", "of", "a", "buildbot", "build", "including", "the", "properties", "." ]

[ "func", "DebugBuild", "(", "c", "context", ".", "Context", ",", "relBuildbotDir", "string", ",", "builder", "string", ",", "buildNum", "int", ")", "(", "*", "ui", ".", "MiloBuildLegacy", ",", "error", ")", "{", "fname", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "builder", ",", "buildNum", ")", "\n", "// ../buildbot below assumes that", "// - this code is not executed by tests outside of this dir", "// - this dir is a sibling of frontend dir", "path", ":=", "filepath", ".", "Join", "(", "relBuildbotDir", ",", "\"", "\"", ",", "fname", ")", "\n", "raw", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "b", ":=", "&", "buildbot", ".", "Build", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "raw", ",", "b", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "renderBuild", "(", "c", ",", "b", ",", "true", ")", ",", "nil", "\n", "}" ]

[ "DebugBuild", "fetches", "a", "debugging", "build", "for", "testing", "." ]

[ "func", "GetBuild", "(", "c", "context", ".", "Context", ",", "id", "buildbot", ".", "BuildID", ")", "(", "*", "ui", ".", "MiloBuildLegacy", ",", "error", ")", "{", "if", "err", ":=", "id", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "buildstore", ".", "CanAccessMaster", "(", "c", ",", "id", ".", "Master", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "switch", "b", ",", "err", ":=", "buildstore", ".", "GetBuild", "(", "c", ",", "id", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "nil", ",", "err", "\n", "case", "b", "==", "nil", ":", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ",", "&", "id", ")", ".", "Tag", "(", "grpcutil", ".", "NotFoundTag", ")", ".", "Err", "(", ")", "\n", "default", ":", "return", "renderBuild", "(", "c", ",", "b", ",", "true", ")", ",", "nil", "\n", "}", "\n", "}" ]

[ "GetBuild", "fetches", "a", "buildbot", "build", "and", "translates", "it", "into", "a", "MiloBuildLegacy", "." ]

[ "func", "LoadTimestamp", "(", "t", "*", "timestamp", ".", "Timestamp", ",", "v", "time", ".", "Time", ")", "*", "timestamp", ".", "Timestamp", "{", "if", "t", "==", "nil", "{", "if", "v", ".", "IsZero", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "t", "=", "&", "timestamp", ".", "Timestamp", "{", "}", "\n", "}", "\n\n", "t", ".", "Seconds", "=", "v", ".", "Unix", "(", ")", "\n", "t", ".", "Nanos", "=", "int32", "(", "v", ".", "Nanosecond", "(", ")", ")", "\n", "return", "t", "\n", "}" ]

[ "LoadTimestamp", "replaces", "the", "value", "in", "the", "supplied", "Timestamp", "with", "the", "specified", "time", ".", "If", "the", "supplied", "Timestamp", "is", "nil", "and", "the", "time", "is", "non", "-", "zero", "a", "new", "Timestamp", "will", "be", "generated", ".", "The", "populated", "Timestamp", "will", "be", "returned", "." ]

[ "func", "TimeFromProto", "(", "t", "*", "timestamp", ".", "Timestamp", ")", "time", ".", "Time", "{", "if", "t", "==", "nil", "{", "return", "time", ".", "Time", "{", "}", "\n", "}", "\n", "return", "time", ".", "Unix", "(", "t", ".", "Seconds", ",", "int64", "(", "t", ".", "Nanos", ")", ")", ".", "UTC", "(", ")", "\n", "}" ]

[ "TimeFromProto", "returns", "the", "time", ".", "Time", "associated", "with", "a", "Timestamp", "protobuf", "." ]

[ "func", "LoadDuration", "(", "d", "*", "duration", ".", "Duration", ",", "v", "time", ".", "Duration", ")", "*", "duration", ".", "Duration", "{", "if", "d", "==", "nil", "{", "if", "v", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "d", "=", "&", "duration", ".", "Duration", "{", "}", "\n", "}", "\n\n", "nanos", ":=", "v", ".", "Nanoseconds", "(", ")", "\n\n", "d", ".", "Seconds", "=", "nanos", "/", "nanosecondsInASecond", "\n", "d", ".", "Nanos", "=", "int32", "(", "nanos", "%", "nanosecondsInASecond", ")", "\n", "return", "d", "\n", "}" ]

[ "LoadDuration", "replaces", "the", "value", "in", "the", "supplied", "Duration", "with", "the", "specified", "value", ".", "If", "the", "supplied", "Duration", "is", "nil", "and", "the", "value", "is", "non", "-", "zero", "a", "new", "Duration", "will", "be", "generated", ".", "The", "populated", "Duration", "will", "be", "returned", "." ]

[ "func", "LRUBackend", "(", "b", "backend", ".", "B", ",", "cache", "*", "lru", ".", "Cache", ",", "exp", "time", ".", "Duration", ")", "backend", ".", "B", "{", "// If our parameters are disabled, just return the underlying Backend.", "if", "exp", "<=", "0", "{", "return", "b", "\n", "}", "\n\n", "// mp is used to block concurrent accesses to the same cache key.", "return", "&", "Backend", "{", "B", ":", "b", ",", "CacheGet", ":", "func", "(", "c", "context", ".", "Context", ",", "key", "Key", ",", "l", "Loader", ")", "(", "ret", "*", "Value", ",", "err", "error", ")", "{", "// Generate the identity component of our cache key.", "//", "// For AsAnonymous and AsService access, we cache based on a singleton", "// identity. For AsUser, however, we cache on a per-user basis.", "var", "id", "identity", ".", "Identity", "\n", "if", "key", ".", "Authority", "==", "backend", ".", "AsUser", "{", "id", "=", "auth", ".", "CurrentIdentity", "(", "c", ")", "\n", "}", "\n\n", "cacheKey", ":=", "mkLRUCacheKey", "(", "&", "key", ",", "id", ")", "\n\n", "// Lock around this key. This will ensure that concurrent accesses to the", "// same key will not result in multiple redundant fetches.", "v", ",", "err", ":=", "cache", ".", "GetOrCreate", "(", "c", ",", "cacheKey", ",", "func", "(", ")", "(", "interface", "{", "}", ",", "time", ".", "Duration", ",", "error", ")", "{", "// The value wasn't in the cache. Resolve and cache it.", "ret", ",", "err", ":=", "l", "(", "c", ",", "key", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "return", "ret", ",", "exp", ",", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "v", ".", "(", "*", "Value", ")", ",", "nil", "\n", "}", ",", "}", "\n", "}" ]

[ "LRUBackend", "wraps", "b", "applying", "the", "additional", "cache", "to", "its", "results", ".", "Do", "NOT", "chain", "multiple", "LRUBackend", "in", "the", "same", "backend", "chain", ".", "An", "LRUBackend", "holds", "a", "LRU", "-", "wide", "lock", "on", "its", "cache", "key", "when", "it", "looks", "up", "its", "value", "and", "if", "a", "second", "entity", "attempts", "to", "lock", "that", "same", "key", "during", "its", "lookup", "chain", "the", "lookup", "will", "deadlock", ".", "If", "the", "supplied", "expiration", "is", "<", "=", "0", "no", "additional", "caching", "will", "be", "performed", "." ]

[ "func", "(", "d", "*", "discoveryDoc", ")", "signingKeys", "(", "c", "context", ".", "Context", ")", "(", "*", "JSONWebKeySet", ",", "error", ")", "{", "fetcher", ":=", "func", "(", ")", "(", "interface", "{", "}", ",", "time", ".", "Duration", ",", "error", ")", "{", "raw", ":=", "&", "JSONWebKeySetStruct", "{", "}", "\n", "req", ":=", "internal", ".", "Request", "{", "Method", ":", "\"", "\"", ",", "URL", ":", "d", ".", "JwksURI", ",", "Out", ":", "raw", ",", "}", "\n", "if", "err", ":=", "req", ".", "Do", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "keys", ",", "err", ":=", "NewJSONWebKeySet", "(", "raw", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "return", "keys", ",", "time", ".", "Hour", "*", "6", ",", "nil", "\n", "}", "\n\n", "cached", ",", "err", ":=", "signingKeysCache", ".", "LRU", "(", "c", ")", ".", "GetOrCreate", "(", "c", ",", "d", ".", "JwksURI", ",", "fetcher", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "cached", ".", "(", "*", "JSONWebKeySet", ")", ",", "nil", "\n", "}" ]

[ "signingKeys", "returns", "a", "JSON", "Web", "Key", "set", "fetched", "from", "the", "location", "specified", "in", "the", "discovery", "document", ".", "It", "fetches", "them", "on", "the", "first", "use", "and", "then", "keeps", "them", "cached", "in", "the", "process", "cache", "for", "6h", ".", "May", "return", "both", "fatal", "and", "transient", "errors", "." ]

[ "func", "fetchDiscoveryDoc", "(", "c", "context", ".", "Context", ",", "url", "string", ")", "(", "*", "discoveryDoc", ",", "error", ")", "{", "if", "url", "==", "\"", "\"", "{", "return", "nil", ",", "ErrNotConfigured", "\n", "}", "\n\n", "fetcher", ":=", "func", "(", ")", "(", "interface", "{", "}", ",", "time", ".", "Duration", ",", "error", ")", "{", "doc", ":=", "&", "discoveryDoc", "{", "}", "\n", "req", ":=", "internal", ".", "Request", "{", "Method", ":", "\"", "\"", ",", "URL", ":", "url", ",", "Out", ":", "doc", ",", "}", "\n", "if", "err", ":=", "req", ".", "Do", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "return", "doc", ",", "time", ".", "Hour", "*", "24", ",", "nil", "\n", "}", "\n\n", "// Cache the document in the process cache.", "cached", ",", "err", ":=", "discoveryDocCache", ".", "LRU", "(", "c", ")", ".", "GetOrCreate", "(", "c", ",", "url", ",", "fetcher", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "cached", ".", "(", "*", "discoveryDoc", ")", ",", "nil", "\n", "}" ]

[ "fetchDiscoveryDoc", "fetches", "discovery", "document", "from", "given", "URL", ".", "It", "is", "cached", "in", "the", "process", "cache", "for", "24", "hours", "." ]

[ "func", "validateStateToken", "(", "c", "context", ".", "Context", ",", "stateTok", "string", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "return", "openIDStateToken", ".", "Validate", "(", "c", ",", "stateTok", ",", "nil", ")", "\n", "}" ]

[ "validateStateToken", "validates", "state", "token", "passed", "to", "redirect_uri", ".", "Returns", "whatever", "state", "was", "passed", "to", "authenticationURI", "." ]

[ "func", "handleAuthorizationCode", "(", "c", "context", ".", "Context", ",", "cfg", "*", "Settings", ",", "code", "string", ")", "(", "uid", "string", ",", "u", "*", "auth", ".", "User", ",", "err", "error", ")", "{", "if", "cfg", ".", "ClientID", "==", "\"", "\"", "||", "cfg", ".", "ClientSecret", "==", "\"", "\"", "||", "cfg", ".", "RedirectURI", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "nil", ",", "ErrNotConfigured", "\n", "}", "\n\n", "// Validate the discover doc has necessary fields to proceed.", "discovery", ",", "err", ":=", "fetchDiscoveryDoc", "(", "c", ",", "cfg", ".", "DiscoveryURL", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "return", "\"", "\"", ",", "nil", ",", "err", "\n", "case", "discovery", ".", "TokenEndpoint", "==", "\"", "\"", ":", "return", "\"", "\"", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Prepare a request to exchange authorization code for the ID token.", "v", ":=", "url", ".", "Values", "{", "}", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "code", ")", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "cfg", ".", "ClientID", ")", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "cfg", ".", "ClientSecret", ")", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "cfg", ".", "RedirectURI", ")", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "payload", ":=", "v", ".", "Encode", "(", ")", "\n\n", "// Send POST to the token endpoint with URL-encoded parameters to get back the", "// ID token. There's more stuff in the reply, we don't need it.", "var", "token", "struct", "{", "IDToken", "string", "`json:\"id_token\"`", "\n", "}", "\n", "req", ":=", "internal", ".", "Request", "{", "Method", ":", "\"", "\"", ",", "URL", ":", "discovery", ".", "TokenEndpoint", ",", "Body", ":", "[", "]", "byte", "(", "payload", ")", ",", "Headers", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", ",", "}", ",", "Out", ":", "&", "token", ",", "}", "\n", "if", "err", ":=", "req", ".", "Do", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "err", "\n", "}", "\n\n", "// Unpack the ID token to grab the user information from it.", "return", "userFromIDToken", "(", "c", ",", "token", ".", "IDToken", ",", "cfg", ",", "discovery", ")", "\n", "}" ]

[ "handleAuthorizationCode", "exchange", "code", "for", "user", "ID", "token", "and", "user", "profile", "." ]

[ "func", "userFromIDToken", "(", "c", "context", ".", "Context", ",", "token", "string", ",", "cfg", "*", "Settings", ",", "discovery", "*", "discoveryDoc", ")", "(", "uid", "string", ",", "u", "*", "auth", ".", "User", ",", "err", "error", ")", "{", "// Validate the discovery doc has necessary fields to proceed.", "switch", "{", "case", "discovery", ".", "Issuer", "==", "\"", "\"", ":", "return", "\"", "\"", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "discovery", ".", "JwksURI", "==", "\"", "\"", ":", "return", "\"", "\"", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Grab the signing keys needed to verify the token. This is almost always", "// hitting the local process cache and thus must be fast.", "signingKeys", ",", "err", ":=", "discovery", ".", "signingKeys", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "err", "\n", "}", "\n\n", "// Unpack the ID token to grab the user information from it.", "verifiedToken", ",", "err", ":=", "VerifyIDToken", "(", "c", ",", "token", ",", "signingKeys", ",", "discovery", ".", "Issuer", ",", "cfg", ".", "ClientID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "err", "\n", "}", "\n\n", "// Ignore non https:// URLs for pictures. We serve all pages over HTTPS and", "// don't want to break this rule just for a pretty picture.", "picture", ":=", "verifiedToken", ".", "Picture", "\n", "if", "picture", "!=", "\"", "\"", "&&", "!", "strings", ".", "HasPrefix", "(", "picture", ",", "\"", "\"", ")", "{", "picture", "=", "\"", "\"", "\n", "}", "\n\n", "// Build the identity string from the email. This essentially validates it.", "id", ",", "err", ":=", "identity", ".", "MakeIdentity", "(", "\"", "\"", "+", "verifiedToken", ".", "Email", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "err", "\n", "}", "\n\n", "return", "verifiedToken", ".", "Sub", ",", "&", "auth", ".", "User", "{", "Identity", ":", "id", ",", "Email", ":", "verifiedToken", ".", "Email", ",", "Name", ":", "verifiedToken", ".", "Name", ",", "Picture", ":", "picture", ",", "}", ",", "nil", "\n", "}" ]

[ "userFromIDToken", "validates", "the", "ID", "token", "and", "extracts", "user", "information", "from", "it", "." ]

[ "func", "(", "o", "Output", ")", "ConfigSets", "(", ")", "[", "]", "ConfigSet", "{", "names", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "o", ".", "Roots", ")", ")", "\n", "for", "name", ":=", "range", "o", ".", "Roots", "{", "names", "=", "append", "(", "names", ",", "name", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "names", ")", "// order is important for logs", "\n\n", "cs", ":=", "make", "(", "[", "]", "ConfigSet", ",", "len", "(", "names", ")", ")", "\n", "for", "i", ",", "nm", ":=", "range", "names", "{", "root", ":=", "o", ".", "Roots", "[", "nm", "]", "\n\n", "// Normalize in preparation for prefix matching.", "root", "=", "path", ".", "Clean", "(", "root", ")", "\n", "if", "root", "==", "\"", "\"", "{", "root", "=", "\"", "\"", "// match EVERYTHING", "\n", "}", "else", "{", "root", "=", "root", "+", "\"", "\"", "// match only what's under 'root/...'", "\n", "}", "\n\n", "files", ":=", "map", "[", "string", "]", "[", "]", "byte", "{", "}", "\n", "for", "f", ",", "body", ":=", "range", "o", ".", "Data", "{", "f", "=", "path", ".", "Clean", "(", "f", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "f", ",", "root", ")", "{", "files", "[", "f", "[", "len", "(", "root", ")", ":", "]", "]", "=", "body", "\n", "}", "\n", "}", "\n\n", "cs", "[", "i", "]", "=", "ConfigSet", "{", "Name", ":", "nm", ",", "Data", ":", "files", "}", "\n", "}", "\n\n", "return", "cs", "\n", "}" ]

[ "ConfigSets", "partitions", "this", "output", "into", "0", "or", "more", "config", "sets", "based", "on", "Roots", "." ]

[ "func", "(", "o", "Output", ")", "Write", "(", "dir", "string", ")", "(", "changed", ",", "unchanged", "[", "]", "string", ",", "err", "error", ")", "{", "// First pass: populate 'changed' and 'unchanged', so we have a valid result", "// even when failing midway through writes.", "changed", ",", "unchanged", "=", "o", ".", "Compare", "(", "dir", ")", "\n\n", "// Second pass: update changed files.", "for", "_", ",", "name", ":=", "range", "changed", "{", "path", ":=", "filepath", ".", "Join", "(", "dir", ",", "filepath", ".", "FromSlash", "(", "name", ")", ")", "\n", "if", "err", "=", "os", ".", "MkdirAll", "(", "filepath", ".", "Dir", "(", "path", ")", ",", "0777", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "err", "=", "ioutil", ".", "WriteFile", "(", "path", ",", "o", ".", "Data", "[", "name", "]", ",", "0666", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Write", "updates", "files", "on", "disk", "to", "match", "the", "output", ".", "Returns", "a", "list", "of", "updated", "files", "and", "a", "list", "of", "files", "that", "are", "already", "up", "-", "to", "-", "date", "same", "as", "Compare", ".", "Creates", "missing", "directories", ".", "Not", "atomic", ".", "All", "files", "have", "mode", "0666", "." ]

[ "func", "(", "o", "Output", ")", "Digests", "(", ")", "map", "[", "string", "]", "string", "{", "out", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "o", ".", "Data", ")", ")", "\n", "for", "file", ",", "body", ":=", "range", "o", ".", "Data", "{", "out", "[", "file", "]", "=", "hex", ".", "EncodeToString", "(", "blobDigest", "(", "body", ")", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "Digests", "returns", "a", "map", "file", "name", "-", ">", "hex", "SHA256", "of", "its", "body", "." ]

[ "func", "(", "o", "Output", ")", "Files", "(", ")", "[", "]", "string", "{", "f", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "o", ".", "Data", ")", ")", "\n", "for", "k", ":=", "range", "o", ".", "Data", "{", "f", "=", "append", "(", "f", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "f", ")", "\n", "return", "f", "\n", "}" ]

[ "Files", "returns", "a", "sorted", "list", "of", "file", "names", "in", "the", "output", "." ]

[ "func", "(", "o", "Output", ")", "DebugDump", "(", ")", "{", "for", "_", ",", "f", ":=", "range", "o", ".", "Files", "(", ")", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "fmt", ".", "Println", "(", "f", ")", "\n", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "fmt", ".", "Print", "(", "string", "(", "o", ".", "Data", "[", "f", "]", ")", ")", "\n", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "DebugDump", "writes", "the", "output", "to", "stdout", "in", "a", "format", "useful", "for", "debugging", "." ]

[ "func", "Generate", "(", "ctx", "context", ".", "Context", ",", "in", "Inputs", ")", "(", "*", "State", ",", "error", ")", "{", "state", ":=", "&", "State", "{", "Inputs", ":", "in", "}", "\n", "ctx", "=", "withState", "(", "ctx", ",", "state", ")", "\n\n", "// All available functions implemented in go.", "predeclared", ":=", "starlark", ".", "StringDict", "{", "// Part of public API of the generator.", "\"", "\"", ":", "builtins", ".", "Fail", ",", "\"", "\"", ":", "starlarkproto", ".", "ProtoLib", "(", ")", "[", "\"", "\"", "]", ",", "\"", "\"", ":", "builtins", ".", "Stacktrace", ",", "\"", "\"", ":", "builtins", ".", "Struct", ",", "\"", "\"", ":", "builtins", ".", "ToJSON", ",", "// '__native__' is NOT public API. It should be used only through public", "// @stdlib functions.", "\"", "\"", ":", "native", "(", "starlark", ".", "StringDict", "{", "\"", "\"", ":", "builtins", ".", "Ctor", ",", "\"", "\"", ":", "builtins", ".", "GenStruct", ",", "\"", "\"", ":", "builtins", ".", "RegexpMatcher", "(", "\"", "\"", ")", ",", "}", ")", ",", "}", "\n", "for", "k", ",", "v", ":=", "range", "in", ".", "testPredeclared", "{", "predeclared", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "// Expose @stdlib, @proto and __main__ package. All have no externally", "// observable state of their own, but they call low-level __native__.*", "// functions that manipulate 'state' by getting it through the context.", "pkgs", ":=", "embeddedPackages", "(", ")", "\n", "pkgs", "[", "interpreter", ".", "MainPkg", "]", "=", "in", ".", "Code", "\n", "pkgs", "[", "\"", "\"", "]", "=", "protoLoader", "(", ")", "// see protos.go", "\n\n", "// Capture details of fail(...) calls happening inside Starlark code.", "failures", ":=", "builtins", ".", "FailureCollector", "{", "}", "\n\n", "// Execute the config script in this environment. Return errors unwrapped so", "// that callers can sniff out various sorts of Starlark errors.", "intr", ":=", "interpreter", ".", "Interpreter", "{", "Predeclared", ":", "predeclared", ",", "Packages", ":", "pkgs", ",", "PreExec", ":", "func", "(", "th", "*", "starlark", ".", "Thread", ",", "pkg", ",", "mod", "string", ")", "{", "state", ".", "vars", ".", "OpenScope", "(", "th", ")", "}", ",", "PostExec", ":", "func", "(", "th", "*", "starlark", ".", "Thread", ",", "pkg", ",", "mod", "string", ")", "{", "state", ".", "vars", ".", "CloseScope", "(", "th", ")", "}", ",", "ThreadModifier", ":", "func", "(", "th", "*", "starlark", ".", "Thread", ")", "{", "if", "!", "in", ".", "testDisableFailureCollector", "{", "failures", ".", "Install", "(", "th", ")", "\n", "}", "\n", "if", "in", ".", "testThreadModifier", "!=", "nil", "{", "in", ".", "testThreadModifier", "(", "th", ")", "\n", "}", "\n", "}", ",", "}", "\n\n", "// Load builtins.star, and then execute the user-supplied script.", "var", "err", "error", "\n", "if", "err", "=", "intr", ".", "Init", "(", "ctx", ")", ";", "err", "==", "nil", "{", "_", ",", "err", "=", "intr", ".", "ExecModule", "(", "ctx", ",", "interpreter", ".", "MainPkg", ",", "in", ".", "Entry", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "if", "f", ":=", "failures", ".", "LatestFailure", "(", ")", ";", "f", "!=", "nil", "{", "err", "=", "f", "// prefer this error, it has custom stack trace", "\n", "}", "\n", "return", "nil", ",", "state", ".", "err", "(", "err", ")", "\n", "}", "\n\n", "// Executing the script (with all its dependencies) populated the graph.", "// Finalize it. This checks there are no dangling edges, freezes the graph,", "// and makes it queryable, so generator callbacks can traverse it.", "if", "errs", ":=", "state", ".", "graph", ".", "Finalize", "(", ")", ";", "len", "(", "errs", ")", "!=", "0", "{", "return", "nil", ",", "state", ".", "err", "(", "errs", "...", ")", "\n", "}", "\n\n", "// The script registered a bunch of callbacks that take the graph and", "// transform it into actual output config files. Run these callbacks now.", "genCtx", ":=", "newGenCtx", "(", ")", "\n", "if", "errs", ":=", "state", ".", "generators", ".", "call", "(", "intr", ".", "Thread", "(", "ctx", ")", ",", "genCtx", ")", ";", "len", "(", "errs", ")", "!=", "0", "{", "return", "nil", ",", "state", ".", "err", "(", "errs", "...", ")", "\n", "}", "\n", "output", ",", "err", ":=", "genCtx", ".", "assembleOutput", "(", "!", "in", ".", "testOmitHeader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "state", ".", "err", "(", "err", ")", "\n", "}", "\n", "state", ".", "Output", "=", "output", "\n\n", "if", "len", "(", "state", ".", "errors", ")", "!=", "0", "{", "return", "nil", ",", "state", ".", "errors", "\n", "}", "\n", "return", "state", ",", "nil", "\n", "}" ]

[ "Generate", "interprets", "the", "high", "-", "level", "config", ".", "Returns", "a", "multi", "-", "error", "with", "all", "captured", "errors", ".", "Some", "of", "them", "may", "implement", "BacktracableError", "interface", "." ]

[ "func", "(", "t", "TagMap", ")", "SortedKeys", "(", ")", "[", "]", "string", "{", "if", "len", "(", "t", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "keys", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "t", ")", ")", "\n", "for", "k", ":=", "range", "t", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n", "return", "keys", "\n", "}" ]

[ "SortedKeys", "returns", "a", "sorted", "slice", "of", "the", "keys", "in", "a", "TagMap", "." ]

[ "func", "NewMockGitilesClient", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockGitilesClient", "{", "mock", ":=", "&", "MockGitilesClient", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockGitilesClientMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockGitilesClient", "creates", "a", "new", "mock", "instance" ]

[ "func", "NewMockGitilesServer", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockGitilesServer", "{", "mock", ":=", "&", "MockGitilesServer", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockGitilesServerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockGitilesServer", "creates", "a", "new", "mock", "instance" ]

[ "func", "UnmarshalUntyped", "(", "flags", "[", "]", "string", ",", "desc", "*", "descriptor", ".", "DescriptorProto", ",", "resolver", "Resolver", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "p", ":=", "parser", "{", "resolver", "}", "\n", "return", "p", ".", "parse", "(", "flags", ",", "desc", ")", "\n", "}" ]

[ "UnmarshalUntyped", "unmarshals", "a", "key", "-", "value", "map", "from", "flags", "using", "a", "protobuf", "message", "descriptor", "." ]

[ "func", "(", "p", "*", "parser", ")", "splitKeyValuePair", "(", "s", "string", ")", "(", "key", ",", "value", "string", ",", "hasValue", "bool", ")", "{", "parts", ":=", "strings", ".", "SplitN", "(", "s", ",", "\"", "\"", ",", "2", ")", "\n", "switch", "len", "(", "parts", ")", "{", "case", "1", ":", "key", "=", "s", "\n", "case", "2", ":", "key", "=", "parts", "[", "0", "]", "\n", "value", "=", "parts", "[", "1", "]", "\n", "hasValue", "=", "true", "\n", "}", "\n", "return", "\n", "}" ]

[ "splitKeyValuePair", "splits", "a", "key", "value", "pair", "key", "=", "value", "if", "there", "is", "equals", "sign", "." ]

[ "func", "parseEnum", "(", "enum", "*", "descriptor", ".", "EnumDescriptorProto", ",", "member", "string", ")", "(", "int32", ",", "error", ")", "{", "i", ":=", "descutil", ".", "FindEnumValue", "(", "enum", ",", "member", ")", "\n", "if", "i", "<", "0", "{", "// Is member the number?", "if", "number", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "member", ",", "10", ",", "32", ")", ";", "err", "==", "nil", "{", "i", "=", "descutil", ".", "FindValueByNumber", "(", "enum", ",", "int32", "(", "number", ")", ")", "\n", "}", "\n", "}", "\n", "if", "i", "<", "0", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "member", ",", "enum", ".", "GetName", "(", ")", ")", "\n", "}", "\n", "return", "enum", ".", "Value", "[", "i", "]", ".", "GetNumber", "(", ")", ",", "nil", "\n", "}" ]

[ "parseEnum", "returns", "the", "number", "of", "an", "enum", "member", "which", "can", "be", "name", "or", "number", "." ]

[ "func", "(", "r", "*", "logRun", ")", "getSteps", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "*", "pb", ".", "Step", ",", "error", ")", "{", "r", ".", "getBuild", ".", "Fields", "=", "&", "field_mask", ".", "FieldMask", "{", "Paths", ":", "[", "]", "string", "{", "\"", "\"", "}", "}", "\n", "build", ",", "err", ":=", "r", ".", "client", ".", "GetBuild", "(", "ctx", ",", "r", ".", "getBuild", ",", "prpc", ".", "ExpectedCode", "(", "codes", ".", "NotFound", ")", ")", "\n", "switch", "status", ".", "Code", "(", "err", ")", "{", "case", "codes", ".", "OK", ":", "return", "build", ".", "Steps", ",", "nil", "\n", "case", "codes", ".", "NotFound", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "default", ":", "return", "nil", ",", "err", "\n", "}", "\n", "}" ]

[ "getSteps", "fetches", "steps", "of", "the", "build", "." ]

[ "func", "(", "m", "*", "logMultiplexer", ")", "Next", "(", ")", "(", "chanIndex", "int", ",", "log", "*", "logpb", ".", "LogEntry", ",", "err", "error", ")", "{", "if", "m", ".", "heads", "==", "nil", "{", "// initialization", "m", ".", "heads", "=", "make", "(", "[", "]", "logAndErr", ",", "len", "(", "m", ".", "Chans", ")", ")", "\n", "for", "i", ":=", "range", "m", ".", "heads", "{", "m", ".", "heads", "[", "i", "]", "=", "<-", "m", ".", "Chans", "[", "i", "]", ".", "c", "\n", "}", "\n", "}", "\n\n", "// Choose the earliest one.", "// Note: using heap is overkill here.", "// Most of the time we deal with only two logs.", "earliest", ":=", "-", "1", "\n", "earliestTime", ":=", "time", ".", "Time", "{", "}", "\n", "for", "i", ",", "h", ":=", "range", "m", ".", "heads", "{", "if", "h", ".", "err", "==", "io", ".", "EOF", "{", "continue", "\n", "}", "\n", "if", "h", ".", "err", "!=", "nil", "{", "return", "0", ",", "nil", ",", "h", ".", "err", "\n", "}", "\n\n", "curTime", ":=", "m", ".", "Chans", "[", "i", "]", ".", "start", "\n", "if", "h", ".", "TimeOffset", "!=", "nil", "{", "offset", ",", "err", ":=", "ptypes", ".", "Duration", "(", "h", ".", "TimeOffset", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "nil", ",", "err", "\n", "}", "\n", "curTime", "=", "curTime", ".", "Add", "(", "offset", ")", "\n", "}", "\n\n", "isEarlier", ":=", "earliest", "==", "-", "1", "||", "curTime", ".", "Before", "(", "earliestTime", ")", "||", "(", "curTime", ".", "Equal", "(", "earliestTime", ")", "&&", "h", ".", "PrefixIndex", "<", "m", ".", "heads", "[", "earliest", "]", ".", "PrefixIndex", ")", "\n", "if", "isEarlier", "{", "earliest", "=", "i", "\n", "earliestTime", "=", "curTime", "\n", "}", "\n", "}", "\n", "if", "earliest", "==", "-", "1", "{", "// all finished", "return", "0", ",", "nil", ",", "io", ".", "EOF", "\n", "}", "\n\n", "// Call f and replace the entry with the freshest one from the same", "// channel.", "earliestEntry", ":=", "m", ".", "heads", "[", "earliest", "]", ".", "LogEntry", "\n", "m", ".", "heads", "[", "earliest", "]", "=", "<-", "m", ".", "Chans", "[", "earliest", "]", ".", "c", "\n", "return", "earliest", ",", "earliestEntry", ",", "nil", "\n", "}" ]

[ "Next", "returns", "the", "next", "log", "entry", ".", "Returns", "io", ".", "EOF", "if", "there", "is", "no", "next", "log", "entry", "." ]

[ "func", "controllerForInvocation", "(", "c", "context", ".", "Context", ",", "e", "*", "engineImpl", ",", "inv", "*", "Invocation", ")", "(", "*", "taskController", ",", "error", ")", "{", "ctl", ":=", "&", "taskController", "{", "ctx", ":", "c", ",", "eng", ":", "e", ",", "saved", ":", "*", "inv", ",", "}", "\n", "var", "err", "error", "\n", "if", "ctl", ".", "task", ",", "err", "=", "e", ".", "cfg", ".", "Catalog", ".", "UnmarshalTask", "(", "c", ",", "inv", ".", "Task", ")", ";", "err", "!=", "nil", "{", "return", "ctl", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "ctl", ".", "manager", "=", "e", ".", "cfg", ".", "Catalog", ".", "GetTaskManager", "(", "ctl", ".", "task", ")", ";", "ctl", ".", "manager", "==", "nil", "{", "return", "ctl", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "=", "ctl", ".", "populateState", "(", ")", ";", "err", "!=", "nil", "{", "return", "ctl", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "ctl", ".", "request", ",", "err", "=", "getRequestFromInv", "(", "&", "ctl", ".", "saved", ")", ";", "err", "!=", "nil", "{", "return", "ctl", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "ctl", ",", "nil", "\n", "}" ]

[ "controllerForInvocation", "returns", "new", "instance", "of", "taskController", "configured", "to", "work", "with", "given", "invocation", ".", "If", "task", "definition", "can", "t", "be", "deserialized", "returns", "both", "controller", "and", "error", "." ]

[ "func", "(", "ctl", "*", "taskController", ")", "populateState", "(", ")", "error", "{", "ctl", ".", "state", "=", "task", ".", "State", "{", "Status", ":", "ctl", ".", "saved", ".", "Status", ",", "ViewURL", ":", "ctl", ".", "saved", ".", "ViewURL", ",", "TaskData", ":", "append", "(", "[", "]", "byte", "(", "nil", ")", ",", "ctl", ".", "saved", ".", "TaskData", "...", ")", ",", "// copy", "}", "\n", "return", "nil", "\n", "}" ]

[ "populateState", "populates", "state", "using", "data", "in", "saved", "." ]

[ "func", "(", "ctl", "*", "taskController", ")", "DebugLog", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "logging", ".", "Infof", "(", "ctl", ".", "ctx", ",", "format", ",", "args", "...", ")", "\n", "debugLog", "(", "ctl", ".", "ctx", ",", "&", "ctl", ".", "debugLog", ",", "format", ",", "args", "...", ")", "\n", "}" ]

[ "DebugLog", "is", "part", "of", "task", ".", "Controller", "interface", "." ]

[ "func", "(", "ctl", "*", "taskController", ")", "AddTimer", "(", "ctx", "context", ".", "Context", ",", "delay", "time", ".", "Duration", ",", "title", "string", ",", "payload", "[", "]", "byte", ")", "{", "// ID for the new timer. It is guaranteed to be unique when we land the", "// transaction because all ctl.saved modifications are serialized in time (see", "// MutationsCount checks in Save), and we include serial number of such", "// modification into the timer id (and suffix it with the index of the timer", "// emitted by this particular modification). If two modification happen", "// concurrently, they may temporary get same timer ID, but only one will", "// actually land.", "timerID", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ctl", ".", "JobID", "(", ")", ",", "ctl", ".", "InvocationID", "(", ")", ",", "ctl", ".", "saved", ".", "MutationsCount", ",", "len", "(", "ctl", ".", "timers", ")", ")", "\n\n", "ctl", ".", "DebugLog", "(", "\"", "\"", ",", "title", ",", "timerID", ",", "delay", ")", "\n\n", "now", ":=", "clock", ".", "Now", "(", "ctx", ")", "\n", "ctl", ".", "timers", "=", "append", "(", "ctl", ".", "timers", ",", "&", "internal", ".", "Timer", "{", "Id", ":", "timerID", ",", "Created", ":", "google", ".", "NewTimestamp", "(", "now", ")", ",", "Eta", ":", "google", ".", "NewTimestamp", "(", "now", ".", "Add", "(", "delay", ")", ")", ",", "Title", ":", "title", ",", "Payload", ":", "payload", ",", "}", ")", "\n", "}" ]

[ "AddTimer", "is", "part", "of", "Controller", "interface", "." ]

[ "func", "(", "ctl", "*", "taskController", ")", "PrepareTopic", "(", "ctx", "context", ".", "Context", ",", "publisher", "string", ")", "(", "topic", "string", ",", "token", "string", ",", "err", "error", ")", "{", "return", "ctl", ".", "eng", ".", "prepareTopic", "(", "ctx", ",", "&", "topicParams", "{", "jobID", ":", "ctl", ".", "JobID", "(", ")", ",", "invID", ":", "ctl", ".", "InvocationID", "(", ")", ",", "manager", ":", "ctl", ".", "manager", ",", "publisher", ":", "publisher", ",", "}", ")", "\n", "}" ]

[ "PrepareTopic", "is", "part", "of", "task", ".", "Controller", "interface", "." ]

[ "func", "(", "ctl", "*", "taskController", ")", "GetClient", "(", "ctx", "context", ".", "Context", ",", "opts", "...", "auth", ".", "RPCOption", ")", "(", "*", "http", ".", "Client", ",", "error", ")", "{", "opts", "=", "append", "(", "opts", ",", "auth", ".", "WithProject", "(", "ctl", ".", "saved", ".", "GetProjectID", "(", ")", ")", ")", "\n", "t", ",", "err", ":=", "auth", ".", "GetRPCTransport", "(", "ctx", ",", "auth", ".", "AsProject", ",", "opts", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "http", ".", "Client", "{", "Transport", ":", "t", "}", ",", "nil", "\n", "}" ]

[ "GetClient", "is", "part", "of", "task", ".", "Controller", "interface" ]

[ "func", "(", "ctl", "*", "taskController", ")", "EmitTrigger", "(", "ctx", "context", ".", "Context", ",", "trigger", "*", "internal", ".", "Trigger", ")", "{", "ctl", ".", "DebugLog", "(", "\"", "\"", ",", "trigger", ".", "Id", ")", "\n", "trigger", ".", "JobId", "=", "ctl", ".", "JobID", "(", ")", "\n", "trigger", ".", "InvocationId", "=", "ctl", ".", "InvocationID", "(", ")", "\n\n", "// See docs for internal.Trigger proto. Tuple (created, order_in_batch) used", "// for casual ordering of triggers emitted by an invocation. Callers of", "// EmitTrigger are free to override this by supplying their own timestamp. In", "// such case they also should provide order_in_batch. Otherwise we build the", "// tuple for them based on the order of EmitTrigger calls.", "if", "trigger", ".", "Created", "==", "nil", "{", "trigger", ".", "Created", "=", "google", ".", "NewTimestamp", "(", "clock", ".", "Now", "(", "ctx", ")", ")", "\n", "trigger", ".", "OrderInBatch", "=", "ctl", ".", "triggerIndex", "\n", "}", "\n\n", "ctl", ".", "triggers", "=", "append", "(", "ctl", ".", "triggers", ",", "trigger", ")", "\n", "ctl", ".", "triggerIndex", "++", "// note: this is NOT reset in Save, unlike ctl.triggers.", "\n", "}" ]

[ "EmitTrigger", "is", "part", "of", "task", ".", "Controller", "interface", "." ]

[ "func", "(", "t", "*", "instrumentedHTTPRoundTripper", ")", "RoundTrip", "(", "origReq", "*", "http", ".", "Request", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "req", ":=", "*", "origReq", "\n\n", "// If a request body was provided, wrap it in a CountingReader so we can see", "// how big it was after it's been sent.", "var", "requestBodyReader", "*", "iotools", ".", "CountingReader", "\n", "if", "req", ".", "Body", "!=", "nil", "{", "requestBodyReader", "=", "&", "iotools", ".", "CountingReader", "{", "Reader", ":", "req", ".", "Body", "}", "\n", "req", ".", "Body", "=", "struct", "{", "io", ".", "Reader", "\n", "io", ".", "Closer", "\n", "}", "{", "requestBodyReader", ",", "req", ".", "Body", "}", "\n", "}", "\n\n", "start", ":=", "clock", ".", "Now", "(", "t", ".", "ctx", ")", "\n", "resp", ",", "err", ":=", "t", ".", "base", ".", "RoundTrip", "(", "&", "req", ")", "\n", "duration", ":=", "clock", ".", "Now", "(", "t", ".", "ctx", ")", ".", "Sub", "(", "start", ")", "\n\n", "var", "requestBytes", "int64", "\n", "if", "requestBodyReader", "!=", "nil", "{", "requestBytes", "=", "requestBodyReader", ".", "Count", "\n", "}", "\n\n", "var", "code", "int", "\n", "var", "responseBytes", "int64", "\n", "if", "resp", "!=", "nil", "{", "code", "=", "resp", ".", "StatusCode", "\n", "responseBytes", "=", "resp", ".", "ContentLength", "\n", "}", "\n\n", "UpdateHTTPMetrics", "(", "t", ".", "ctx", ",", "req", ".", "URL", ".", "Host", ",", "t", ".", "client", ",", "code", ",", "duration", ",", "requestBytes", ",", "responseBytes", ")", "\n\n", "return", "resp", ",", "err", "\n", "}" ]

[ "RoundTrip", "implements", "http", ".", "RoundTripper", "." ]

[ "func", "(", "mc", "*", "MessageCache", ")", "Get", "(", "c", "context", ".", "Context", ",", "cset", "config", ".", "Set", ",", "path", "string", ",", "msg", "proto", ".", "Message", ")", "(", "proto", ".", "Message", ",", "error", ")", "{", "// If no Lifetime is configured, bypass the cache layer.", "if", "mc", ".", "Lifetime", "<=", "0", "{", "err", ":=", "mc", ".", "GetUncached", "(", "c", ",", "cset", ",", "path", ",", "msg", ")", "\n", "return", "msg", ",", "err", "\n", "}", "\n\n", "key", ":=", "messageCacheKey", "{", "cset", ",", "path", "}", "\n\n", "// Load the value from our cache. First, though, take out a lock on this", "// specific config key. This will prevent multiple concurrent accesses from", "// slamming the config service, particularly at startup.", "var", "v", "interface", "{", "}", "\n", "var", "err", "error", "\n", "v", ",", "err", "=", "messageCache", ".", "LRU", "(", "c", ")", ".", "GetOrCreate", "(", "c", ",", "key", ",", "func", "(", ")", "(", "interface", "{", "}", ",", "time", ".", "Duration", ",", "error", ")", "{", "// Not in cache or expired. Reload...", "if", "err", ":=", "mc", ".", "GetUncached", "(", "c", ",", "cset", ",", "path", ",", "msg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "return", "proto", ".", "Clone", "(", "msg", ")", ",", "mc", ".", "Lifetime", ",", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "v", ".", "(", "proto", ".", "Message", ")", ",", "nil", "\n", "}" ]

[ "Get", "returns", "an", "unmarshalled", "configuration", "service", "text", "protobuf", "message", ".", "If", "the", "message", "is", "not", "currently", "in", "the", "process", "cache", "it", "will", "be", "fetched", "from", "the", "config", "service", "and", "cached", "prior", "to", "being", "returned", "." ]

[ "func", "(", "mc", "*", "MessageCache", ")", "GetUncached", "(", "c", "context", ".", "Context", ",", "cset", "config", ".", "Set", ",", "path", "string", ",", "msg", "proto", ".", "Message", ")", "error", "{", "return", "cfgclient", ".", "Get", "(", "c", ",", "cfgclient", ".", "AsService", ",", "cset", ",", "path", ",", "textproto", ".", "Message", "(", "msg", ")", ",", "nil", ")", "\n", "}" ]

[ "GetUncached", "returns", "an", "unmarshalled", "configuration", "service", "text", "protobuf", "message", ".", "This", "bypasses", "the", "cache", "and", "on", "success", "does", "not", "cache", "the", "resulting", "value", "." ]

[ "func", "(", "s", "*", "StaticSource", ")", "NextLogEntry", "(", ")", "(", "le", "*", "logpb", ".", "LogEntry", ",", "err", "error", ")", "{", "// Pop the next entry, mutating s.", "if", "len", "(", "*", "s", ")", ">", "0", "{", "le", ",", "*", "s", "=", "(", "*", "s", ")", "[", "0", "]", ",", "(", "*", "s", ")", "[", "1", ":", "]", "\n", "}", "\n", "if", "len", "(", "*", "s", ")", "==", "0", "{", "err", "=", "io", ".", "EOF", "\n", "}", "\n", "return", "\n", "}" ]

[ "NextLogEntry", "implements", "Source", "." ]

[ "func", "WriteInt", "(", "w", "io", ".", "ByteWriter", ",", "val", "int64", ")", "(", "int", ",", "error", ")", "{", "var", "inv", "byte", "\n", "if", "val", "<", "0", "{", "inv", "=", "0xff", "\n", "}", "\n", "mag", ":=", "uint64", "(", "val", ")", "\n", "if", "inv", "!=", "0", "{", "mag", "=", "-", "mag", "\n", "}", "\n", "return", "writeSignMag", "(", "w", ",", "mag", ",", "inv", ")", "\n", "}" ]

[ "WriteInt", "val", "as", "a", "cmpbin", "Int", "to", "the", "ByteWriter", ".", "Returns", "the", "number", "of", "bytes", "written", ".", "Only", "returns", "an", "error", "if", "the", "underlying", "ByteWriter", "returns", "an", "error", "." ]

[ "func", "WriteUint", "(", "w", "io", ".", "ByteWriter", ",", "mag", "uint64", ")", "(", "int", ",", "error", ")", "{", "return", "writeSignMag", "(", "w", ",", "mag", ",", "0", ")", "\n", "}" ]

[ "WriteUint", "writes", "mag", "to", "the", "ByteWriter", ".", "Returns", "the", "number", "of", "bytes", "written", ".", "Only", "returns", "an", "error", "if", "the", "underlying", "ByteWriter", "returns", "an", "error", "." ]

[ "func", "WithPanicCatcher", "(", "c", "*", "router", ".", "Context", ",", "next", "router", ".", "Handler", ")", "{", "ctx", ":=", "c", ".", "Context", "\n", "w", ":=", "c", ".", "Writer", "\n", "req", ":=", "c", ".", "Request", "\n", "defer", "paniccatcher", ".", "Catch", "(", "func", "(", "p", "*", "paniccatcher", ".", "Panic", ")", "{", "// Log the reason before the stack in case appengine cuts entire log", "// message due to size limitations.", "log", ".", "Fields", "{", "\"", "\"", ":", "p", ".", "Reason", ",", "}", ".", "Errorf", "(", "ctx", ",", "\"", "\\n", "\"", ",", "req", ".", "RequestURI", ",", "p", ".", "Reason", ",", "p", ".", "Stack", ")", "\n\n", "// Note: it may be too late to send HTTP 500 if `next` already sent", "// headers. But there's nothing else we can do at this point anyway.", "http", ".", "Error", "(", "w", ",", "\"", "\"", ",", "http", ".", "StatusInternalServerError", ")", "\n", "}", ")", "\n", "next", "(", "c", ")", "\n", "}" ]

[ "WithPanicCatcher", "is", "a", "middleware", "that", "catches", "panics", "dumps", "stack", "trace", "to", "logging", "and", "returns", "HTTP", "500", "." ]

[ "func", "(", "s", "*", "Signer", ")", "SignBytes", "(", "c", "context", ".", "Context", ",", "blob", "[", "]", "byte", ")", "(", "string", ",", "[", "]", "byte", ",", "error", ")", "{", "return", "s", ".", "Client", ".", "SignBlob", "(", "c", ",", "s", ".", "ServiceAccount", ",", "blob", ")", "\n", "}" ]

[ "SignBytes", "signs", "the", "blob", "with", "some", "active", "private", "key", ".", "Hashes", "the", "blob", "using", "SHA256", "and", "then", "calculates", "RSASSA", "-", "PKCS1", "-", "v1_5", "signature", "using", "the", "currently", "active", "signing", "key", ".", "Returns", "the", "signature", "and", "name", "of", "the", "key", "used", "." ]

[ "func", "NewDBCache", "(", "updater", "DBCacheUpdater", ")", "func", "(", "c", "context", ".", "Context", ")", "(", "DB", ",", "error", ")", "{", "cacheSlot", ":=", "lazyslot", ".", "Slot", "{", "}", "\n", "return", "func", "(", "c", "context", ".", "Context", ")", "(", "DB", ",", "error", ")", "{", "val", ",", "err", ":=", "cacheSlot", ".", "Get", "(", "c", ",", "func", "(", "prev", "interface", "{", "}", ")", "(", "db", "interface", "{", "}", ",", "exp", "time", ".", "Duration", ",", "err", "error", ")", "{", "prevDB", ",", "_", ":=", "prev", ".", "(", "DB", ")", "\n", "if", "db", ",", "err", "=", "updater", "(", "c", ",", "prevDB", ")", ";", "err", "==", "nil", "{", "exp", "=", "5", "*", "time", ".", "Second", "+", "time", ".", "Duration", "(", "mathrand", ".", "Get", "(", "c", ")", ".", "Intn", "(", "5000", ")", ")", "*", "time", ".", "Millisecond", "\n", "}", "\n", "return", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "val", ".", "(", "DB", ")", ",", "nil", "\n", "}", "\n", "}" ]

[ "NewDBCache", "returns", "a", "provider", "of", "DB", "instances", "that", "uses", "local", "memory", "to", "cache", "DB", "instances", "for", "5", "-", "10", "seconds", ".", "It", "uses", "supplied", "callback", "to", "refetch", "DB", "from", "some", "permanent", "storage", "when", "cache", "expires", ".", "Even", "though", "the", "return", "value", "is", "technically", "a", "function", "treat", "it", "as", "a", "heavy", "stateful", "object", "since", "it", "has", "the", "cache", "of", "DB", "in", "its", "closure", "." ]

[ "func", "(", "t", "*", "KVMsTable", ")", "fetch", "(", "c", "context", ".", "Context", ")", "error", "{", "db", ":=", "database", ".", "Get", "(", "c", ")", "\n", "rows", ",", "err", ":=", "db", ".", "QueryContext", "(", "c", ",", "`\n\t\tSELECT k.id, h.id, h.name, i.ipv4, k.description, k.mac_address, k.state, k.platform_id, k.rack_id\n\t\tFROM kvms k, hostnames h, ips i\n\t\tWHERE k.hostname_id = h.id AND i.hostname_id = h.id\n\t`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n", "for", "rows", ".", "Next", "(", ")", "{", "kvm", ":=", "&", "KVM", "{", "}", "\n", "if", "err", ":=", "rows", ".", "Scan", "(", "&", "kvm", ".", "Id", ",", "&", "kvm", ".", "HostnameId", ",", "&", "kvm", ".", "Name", ",", "&", "kvm", ".", "IPv4", ",", "&", "kvm", ".", "Description", ",", "&", "kvm", ".", "MacAddress", ",", "&", "kvm", ".", "State", ",", "&", "kvm", ".", "PlatformId", ",", "&", "kvm", ".", "RackId", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "t", ".", "current", "=", "append", "(", "t", ".", "current", ",", "kvm", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

[ "func", "(", "t", "*", "KVMsTable", ")", "computeChanges", "(", "c", "context", ".", "Context", ",", "datacenters", "[", "]", "*", "config", ".", "Datacenter", ")", "error", "{", "cfgs", ":=", "make", "(", "map", "[", "string", "]", "*", "KVM", ",", "len", "(", "datacenters", ")", ")", "\n", "for", "_", ",", "dc", ":=", "range", "datacenters", "{", "for", "_", ",", "cfg", ":=", "range", "dc", ".", "Kvm", "{", "ipv4", ",", "err", ":=", "common", ".", "ParseIPv4", "(", "cfg", ".", "Ipv4", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "cfg", ".", "Name", ",", "cfg", ".", "Ipv4", ")", ".", "Err", "(", ")", "\n", "}", "\n", "mac48", ",", "err", ":=", "common", ".", "ParseMAC48", "(", "cfg", ".", "MacAddress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "cfg", ".", "Name", ",", "cfg", ".", "MacAddress", ")", ".", "Err", "(", ")", "\n", "}", "\n", "pId", ",", "ok", ":=", "t", ".", "platforms", "[", "cfg", ".", "Platform", "]", "\n", "if", "!", "ok", "{", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "cfg", ".", "Name", ",", "cfg", ".", "Platform", ")", ".", "Err", "(", ")", "\n", "}", "\n", "rId", ",", "ok", ":=", "t", ".", "racks", "[", "cfg", ".", "Rack", "]", "\n", "if", "!", "ok", "{", "return", "errors", ".", "Reason", "(", "\"", "\"", ",", "cfg", ".", "Name", ",", "cfg", ".", "Rack", ")", ".", "Err", "(", ")", "\n", "}", "\n", "cfgs", "[", "cfg", ".", "Name", "]", "=", "&", "KVM", "{", "KVM", ":", "config", ".", "KVM", "{", "Name", ":", "cfg", ".", "Name", ",", "Description", ":", "cfg", ".", "Description", ",", "State", ":", "cfg", ".", "State", ",", "}", ",", "IPv4", ":", "ipv4", ",", "MacAddress", ":", "mac48", ",", "PlatformId", ":", "pId", ",", "RackId", ":", "rId", ",", "}", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "kvm", ":=", "range", "t", ".", "current", "{", "if", "cfg", ",", "ok", ":=", "cfgs", "[", "kvm", ".", "Name", "]", ";", "ok", "{", "// KVM found in the config.", "if", "t", ".", "needsUpdate", "(", "kvm", ",", "cfg", ")", "{", "// KVM doesn't match the config.", "cfg", ".", "Id", "=", "kvm", ".", "Id", "\n", "t", ".", "updates", "=", "append", "(", "t", ".", "updates", ",", "cfg", ")", "\n", "}", "\n", "// Record that the KVM config has been seen.", "delete", "(", "cfgs", ",", "cfg", ".", "Name", ")", "\n", "}", "else", "{", "// KVM not found in the config.", "t", ".", "removals", "=", "append", "(", "t", ".", "removals", ",", "kvm", ")", "\n", "}", "\n", "}", "\n\n", "// KVMs remaining in the map are present in the config but not the database.", "// Iterate deterministically over the slices to determine which KVMs need to be added.", "for", "_", ",", "dc", ":=", "range", "datacenters", "{", "for", "_", ",", "cfg", ":=", "range", "dc", ".", "Kvm", "{", "if", "kvm", ",", "ok", ":=", "cfgs", "[", "cfg", ".", "Name", "]", ";", "ok", "{", "t", ".", "additions", "=", "append", "(", "t", ".", "additions", ",", "kvm", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

[ "func", "(", "t", "*", "KVMsTable", ")", "add", "(", "c", "context", ".", "Context", ")", "error", "{", "// Avoid using the database connection to prepare unnecessary statements.", "if", "len", "(", "t", ".", "additions", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "tx", ",", "err", ":=", "database", ".", "Begin", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "tx", ".", "MaybeRollback", "(", "c", ")", "\n", "stmt", ",", "err", ":=", "tx", ".", "PrepareContext", "(", "c", ",", "`\n\t\tINSERT INTO kvms (hostname_id, description, mac_address, state, platform_id, rack_id)\n\t\tVALUES (?, ?, ?, ?, ?, ?)\n\t`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "stmt", ".", "Close", "(", ")", "\n\n", "// Add each KVM to the database, and update the slice of KVMs with each addition.", "for", "len", "(", "t", ".", "additions", ")", ">", "0", "{", "kvm", ":=", "t", ".", "additions", "[", "0", "]", "\n", "hostnameId", ",", "err", ":=", "AssignHostnameAndIP", "(", "c", ",", "tx", ",", "kvm", ".", "Name", ",", "kvm", ".", "IPv4", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "kvm", ".", "Name", ")", ".", "Err", "(", ")", "\n", "}", "\n", "result", ",", "err", ":=", "stmt", ".", "ExecContext", "(", "c", ",", "hostnameId", ",", "kvm", ".", "Description", ",", "kvm", ".", "MacAddress", ",", "kvm", ".", "State", ",", "kvm", ".", "PlatformId", ",", "kvm", ".", "RackId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "kvm", ".", "Name", ")", ".", "Err", "(", ")", "\n", "}", "\n", "t", ".", "current", "=", "append", "(", "t", ".", "current", ",", "kvm", ")", "\n", "t", ".", "additions", "=", "t", ".", "additions", "[", "1", ":", "]", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "kvm", ".", "Name", ")", "\n", "kvm", ".", "Id", ",", "err", "=", "result", ".", "LastInsertId", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "kvm", ".", "Name", ")", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "tx", ".", "Commit", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "add", "adds", "all", "KVMs", "pending", "addition", "to", "the", "database", "clearing", "pending", "additions", ".", "No", "-", "op", "unless", "computeChanges", "was", "called", "first", ".", "Idempotent", "until", "computeChanges", "is", "called", "again", "." ]

[ "func", "(", "t", "*", "KVMsTable", ")", "remove", "(", "c", "context", ".", "Context", ")", "error", "{", "// Avoid using the database connection to prepare unnecessary statements.", "if", "len", "(", "t", ".", "removals", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "db", ":=", "database", ".", "Get", "(", "c", ")", "\n", "// By setting kvms.hostname_id ON DELETE CASCADE when setting up the database, we can avoid", "// having to explicitly delete the KVM here. MySQL will cascade the deletion to the KVM.", "stmt", ",", "err", ":=", "db", ".", "PrepareContext", "(", "c", ",", "`\n\t\tDELETE FROM hostnames\n\t\tWHERE id = ?\n\t`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "stmt", ".", "Close", "(", ")", "\n\n", "// Remove each KVM from the table. It's more efficient to update the slice of", "// KVMs once at the end rather than for each removal, so use a defer.", "removed", ":=", "make", "(", "map", "[", "int64", "]", "struct", "{", "}", ",", "len", "(", "t", ".", "removals", ")", ")", "\n", "defer", "func", "(", ")", "{", "var", "kvms", "[", "]", "*", "KVM", "\n", "for", "_", ",", "kvm", ":=", "range", "t", ".", "current", "{", "if", "_", ",", "ok", ":=", "removed", "[", "kvm", ".", "Id", "]", ";", "!", "ok", "{", "kvms", "=", "append", "(", "kvms", ",", "kvm", ")", "\n", "}", "\n", "}", "\n", "t", ".", "current", "=", "kvms", "\n", "}", "(", ")", "\n", "for", "len", "(", "t", ".", "removals", ")", ">", "0", "{", "kvm", ":=", "t", ".", "removals", "[", "0", "]", "\n", "if", "_", ",", "err", ":=", "stmt", ".", "ExecContext", "(", "c", ",", "kvm", ".", "HostnameId", ")", ";", "err", "!=", "nil", "{", "// Defer ensures the slice of KVMs is updated even if we exit early.", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "kvm", ".", "Name", ")", ".", "Err", "(", ")", "\n", "}", "\n", "removed", "[", "kvm", ".", "Id", "]", "=", "struct", "{", "}", "{", "}", "\n", "t", ".", "removals", "=", "t", ".", "removals", "[", "1", ":", "]", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "kvm", ".", "Name", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

[ "func", "(", "t", "*", "KVMsTable", ")", "update", "(", "c", "context", ".", "Context", ")", "error", "{", "// Avoid using the database connection to prepare unnecessary statements.", "if", "len", "(", "t", ".", "updates", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "db", ":=", "database", ".", "Get", "(", "c", ")", "\n", "// TODO(smut): Update IP address.", "stmt", ",", "err", ":=", "db", ".", "PrepareContext", "(", "c", ",", "`\n\t\tUPDATE kvms\n\t\tSET description = ?, mac_address = ?, state = ?, platform_id = ?, rack_id = ?\n\t\tWHERE id = ?\n\t`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "stmt", ".", "Close", "(", ")", "\n\n", "// Update each KVM in the table. It's more efficient to update the slice of", "// KVMs once at the end rather than for each update, so use a defer.", "updated", ":=", "make", "(", "map", "[", "int64", "]", "*", "KVM", ",", "len", "(", "t", ".", "updates", ")", ")", "\n", "defer", "func", "(", ")", "{", "for", "_", ",", "kvm", ":=", "range", "t", ".", "current", "{", "if", "u", ",", "ok", ":=", "updated", "[", "kvm", ".", "Id", "]", ";", "ok", "{", "kvm", ".", "MacAddress", "=", "u", ".", "MacAddress", "\n", "kvm", ".", "Description", "=", "u", ".", "Description", "\n", "kvm", ".", "State", "=", "u", ".", "State", "\n", "kvm", ".", "PlatformId", "=", "u", ".", "PlatformId", "\n", "kvm", ".", "RackId", "=", "u", ".", "RackId", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "for", "len", "(", "t", ".", "updates", ")", ">", "0", "{", "kvm", ":=", "t", ".", "updates", "[", "0", "]", "\n", "if", "_", ",", "err", ":=", "stmt", ".", "ExecContext", "(", "c", ",", "kvm", ".", "Description", ",", "kvm", ".", "MacAddress", ",", "kvm", ".", "State", ",", "kvm", ".", "PlatformId", ",", "kvm", ".", "RackId", ",", "kvm", ".", "Id", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "kvm", ".", "Name", ")", ".", "Err", "(", ")", "\n", "}", "\n", "updated", "[", "kvm", ".", "Id", "]", "=", "kvm", "\n", "t", ".", "updates", "=", "t", ".", "updates", "[", "1", ":", "]", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "kvm", ".", "Name", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

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

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

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

[ "EnsureKVMs", "ensures", "the", "database", "contains", "exactly", "the", "given", "KVMs", ".", "Returns", "a", "map", "of", "KVM", "names", "to", "IDs", "in", "the", "database", "." ]

[ "func", "encode", "(", "src", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "jsoninsh", ",", "err", ":=", "json", ".", "Marshal", "(", "src", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "buf", "bytes", ".", "Buffer", "\n", "gsw", ":=", "gzip", ".", "NewWriter", "(", "&", "buf", ")", "\n", "_", ",", "err", "=", "gsw", ".", "Write", "(", "jsoninsh", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "err", "=", "gsw", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "buf", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "encode", "marshals", "src", "to", "JSON", "and", "compresses", "it", "." ]

[ "func", "decode", "(", "dest", "interface", "{", "}", ",", "data", "[", "]", "byte", ")", "error", "{", "reader", ",", "err", ":=", "gzip", ".", "NewReader", "(", "bytes", ".", "NewReader", "(", "data", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "json", ".", "NewDecoder", "(", "reader", ")", ".", "Decode", "(", "dest", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "reader", ".", "Close", "(", ")", "\n", "}" ]

[ "decode", "decompresses", "data", "and", "unmarshals", "into", "dest", "as", "JSON", "." ]

[ "func", "ParseModule", "(", "filename", ",", "body", "string", ")", "(", "*", "Module", ",", "error", ")", "{", "ast", ",", "err", ":=", "syntax", ".", "Parse", "(", "filename", ",", "body", ",", "syntax", ".", "RetainComments", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "m", ":=", "&", "Module", "{", "docstring", ":", "extractDocstring", "(", "ast", ".", "Stmts", ")", "}", "\n", "m", ".", "populateFromAST", "(", "filename", ",", "ast", ")", "\n\n", "// emit adds a node to the module.", "emit", ":=", "func", "(", "name", "string", ",", "ast", "syntax", ".", "Node", ",", "n", "Node", ")", "{", "n", ".", "populateFromAST", "(", "name", ",", "ast", ")", "\n", "m", ".", "Nodes", "=", "append", "(", "m", ".", "Nodes", ",", "n", ")", "\n", "}", "\n\n", "// Walk over top-level statements and match them against patterns we recognize", "// as relevant.", "for", "_", ",", "stmt", ":=", "range", "ast", ".", "Stmts", "{", "switch", "st", ":=", "stmt", ".", "(", "type", ")", "{", "case", "*", "syntax", ".", "LoadStmt", ":", "// A load(...) statement. Each imported symbol ends up in the module's", "// namespace, so add corresponding ExternalReference nodes.", "for", "i", ",", "nm", ":=", "range", "st", ".", "To", "{", "emit", "(", "nm", ".", "Name", ",", "st", ",", "&", "ExternalReference", "{", "ExternalName", ":", "st", ".", "From", "[", "i", "]", ".", "Name", ",", "Module", ":", "st", ".", "Module", ".", "Value", ".", "(", "string", ")", ",", "}", ")", "\n", "}", "\n\n", "case", "*", "syntax", ".", "DefStmt", ":", "// A function declaration: \"def name(...)\".", "emit", "(", "st", ".", "Name", ".", "Name", ",", "st", ",", "&", "Function", "{", "docstring", ":", "extractDocstring", "(", "st", ".", "Body", ")", ",", "}", ")", "\n\n", "case", "*", "syntax", ".", "AssignStmt", ":", "// A top level assignment. We care only about <var> = ... (i.e. when LHS", "// is a simple variable, not a tuple or anything like that).", "if", "st", ".", "Op", "!=", "syntax", ".", "EQ", "{", "continue", "\n", "}", "\n", "lhs", ":=", "matchSingleIdent", "(", "st", ".", "LHS", ")", "\n", "if", "lhs", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "if", "n", ":=", "parseAssignmentRHS", "(", "st", ".", "RHS", ")", ";", "n", "!=", "nil", "{", "emit", "(", "lhs", ",", "st", ",", "n", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "m", ",", "nil", "\n", "}" ]

[ "ParseModule", "parses", "a", "single", "Starlark", "module", ".", "Filename", "is", "only", "used", "when", "recording", "position", "information", "." ]

[ "func", "extractDocstring", "(", "body", "[", "]", "syntax", ".", "Stmt", ")", "string", "{", "if", "len", "(", "body", ")", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "expr", ",", "ok", ":=", "body", "[", "0", "]", ".", "(", "*", "syntax", ".", "ExprStmt", ")", "\n", "if", "!", "ok", "{", "return", "\"", "\"", "\n", "}", "\n", "literal", ",", "ok", ":=", "expr", ".", "X", ".", "(", "*", "syntax", ".", "Literal", ")", "\n", "if", "!", "ok", "||", "literal", ".", "Token", "!=", "syntax", ".", "STRING", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "literal", ".", "Value", ".", "(", "string", ")", "\n", "}" ]

[ "extractDocstring", "returns", "a", "doc", "string", "for", "the", "given", "body", ".", "A", "docstring", "is", "a", "string", "literal", "that", "comes", "first", "in", "the", "body", "if", "any", "." ]

[ "func", "processBuilders", "(", "c", "context", ".", "Context", ",", "r", "*", "swarmbucketAPI", ".", "LegacySwarmbucketApiGetBuildersResponseMessage", ")", "(", "[", "]", "model", ".", "PoolDescriptor", ",", "error", ")", "{", "var", "builderPools", "[", "]", "model", ".", "BuilderPool", "\n", "var", "descriptors", "[", "]", "model", ".", "PoolDescriptor", "\n", "seen", ":=", "stringset", ".", "New", "(", "0", ")", "\n", "for", "_", ",", "bucket", ":=", "range", "r", ".", "Buckets", "{", "for", "_", ",", "builder", ":=", "range", "bucket", ".", "Builders", "{", "bid", ":=", "NewBuilderID", "(", "bucket", ".", "Name", ",", "builder", ".", "Name", ")", "\n", "if", "bid", ".", "Project", "==", "\"", "\"", "{", "// This may happen if the bucket or builder does not fulfill the LUCI", "// naming convention.", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "bucket", ".", "Name", ",", "builder", ".", "Name", ")", "\n", "continue", "\n", "}", "\n", "id", ":=", "bid", ".", "String", "(", ")", "\n", "dimensions", ":=", "stripEmptyDimensions", "(", "builder", ".", "SwarmingDimensions", ")", "\n", "descriptor", ":=", "model", ".", "NewPoolDescriptor", "(", "builder", ".", "SwarmingHostname", ",", "dimensions", ")", "\n", "dID", ":=", "descriptor", ".", "PoolID", "(", ")", "\n", "builderPools", "=", "append", "(", "builderPools", ",", "model", ".", "BuilderPool", "{", "BuilderID", ":", "datastore", ".", "MakeKey", "(", "c", ",", "model", ".", "BuilderSummaryKind", ",", "id", ")", ",", "PoolKey", ":", "datastore", ".", "MakeKey", "(", "c", ",", "model", ".", "BotPoolKind", ",", "dID", ")", ",", "}", ")", "\n", "if", "added", ":=", "seen", ".", "Add", "(", "dID", ")", ";", "added", "{", "descriptors", "=", "append", "(", "descriptors", ",", "descriptor", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "descriptors", ",", "datastore", ".", "Put", "(", "c", ",", "builderPools", ")", "\n", "}" ]

[ "processBuilders", "parses", "out", "all", "of", "the", "builder", "pools", "from", "the", "Swarmbucket", "get_builders", "response", "and", "saves", "the", "BuilderPool", "information", "into", "the", "datastore", ".", "It", "returns", "a", "list", "of", "PoolDescriptors", "that", "needs", "to", "be", "fetched", "and", "saved", "." ]

[ "func", "processBot", "(", "c", "context", ".", "Context", ",", "desc", "model", ".", "PoolDescriptor", ")", "error", "{", "t", ",", "err", ":=", "auth", ".", "GetRPCTransport", "(", "c", ",", "auth", ".", "AsSelf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "sc", ",", "err", ":=", "swarmingAPI", ".", "New", "(", "&", "http", ".", "Client", "{", "Transport", ":", "t", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "sc", ".", "BasePath", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "desc", ".", "Host", "(", ")", ")", "\n\n", "var", "bots", "[", "]", "model", ".", "Bot", "\n", "bl", ":=", "sc", ".", "Bots", ".", "List", "(", ")", ".", "Dimensions", "(", "desc", ".", "Dimensions", "(", ")", ".", "Format", "(", ")", "...", ")", "\n", "// Keep fetching until the cursor is empty.", "for", "{", "botList", ",", "err", ":=", "bl", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "botInfo", ":=", "range", "botList", ".", "Items", "{", "// Ignore deleted bots.", "if", "botInfo", ".", "Deleted", "{", "continue", "\n", "}", "\n", "bot", ",", "err", ":=", "parseBot", "(", "c", ",", "desc", ".", "Host", "(", ")", ",", "botInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "bots", "=", "append", "(", "bots", ",", "*", "bot", ")", "\n", "}", "\n\n", "if", "botList", ".", "Cursor", "==", "\"", "\"", "{", "break", "\n", "}", "\n", "bl", "=", "bl", ".", "Cursor", "(", "botList", ".", "Cursor", ")", "\n", "}", "\n", "// If there are too many bots, then it won't fit in datastore.", "// Only store a subset of the bots.", "// TODO(hinoka): This is inaccurate, but will only affect few builders.", "// Instead of chopping this list off, just store the statistics.", "if", "len", "(", "bots", ")", ">", "1000", "{", "bots", "=", "bots", "[", ":", "1000", "]", "\n", "}", "\n", "// This is a large RPC, don't try to batch it.", "return", "datastore", ".", "Put", "(", "c", ",", "&", "model", ".", "BotPool", "{", "PoolID", ":", "desc", ".", "PoolID", "(", ")", ",", "Descriptor", ":", "desc", ",", "Bots", ":", "bots", ",", "LastUpdate", ":", "clock", ".", "Now", "(", "c", ")", ",", "}", ")", "\n", "}" ]

[ "processBot", "retrieves", "the", "Bot", "pool", "details", "from", "Swarming", "for", "a", "given", "set", "of", "dimensions", "for", "its", "respective", "Swarming", "host", "and", "saves", "the", "data", "into", "datastore", "." ]

[ "func", "(", "tr", "TimerResult", ")", "Incomplete", "(", ")", "bool", "{", "switch", "tr", ".", "Err", "{", "case", "nil", ":", "return", "false", "\n", "case", "context", ".", "Canceled", ",", "context", ".", "DeadlineExceeded", ":", "return", "true", "\n", "default", ":", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tr", ".", "Err", ")", ")", "\n", "}", "\n", "}" ]

[ "Incomplete", "will", "return", "true", "if", "the", "timer", "result", "indicates", "that", "the", "timer", "operation", "was", "canceled", "prematurely", "due", "to", "Context", "cancellation", "or", "deadline", "expiration", "." ]

[ "func", "(", "bf", "*", "BitField", ")", "MarshalBinary", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "ret", ":=", "make", "(", "[", "]", "byte", ",", "binary", ".", "MaxVarintLen32", "+", "len", "(", "bf", ".", "data", ")", ")", "\n", "n", ":=", "binary", ".", "PutUvarint", "(", "ret", ",", "uint64", "(", "bf", ".", "size", ")", ")", "\n", "n", "+=", "copy", "(", "ret", "[", "n", ":", "]", ",", "bf", ".", "data", ")", "\n", "return", "ret", "[", ":", "n", "]", ",", "nil", "\n", "}" ]

[ "MarshalBinary", "implements", "encoding", ".", "BinaryMarshaller" ]

[ "func", "(", "bf", "*", "BitField", ")", "UnmarshalBinary", "(", "bs", "[", "]", "byte", ")", "error", "{", "buf", ":=", "bytes", ".", "NewBuffer", "(", "bs", ")", "\n", "n", ",", "err", ":=", "binary", ".", "ReadUvarint", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "n", ">", "math", ".", "MaxUint32", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "n", ",", "uint32", "(", "math", ".", "MaxUint32", ")", ")", "\n", "}", "\n\n", "size", ":=", "uint32", "(", "n", ")", "\n", "if", "size", "==", "0", "{", "bf", ".", "size", "=", "0", "\n", "bf", ".", "data", "=", "nil", "\n", "return", "nil", "\n", "}", "\n", "data", ":=", "buf", ".", "Bytes", "(", ")", "\n", "if", "uint32", "(", "len", "(", "data", ")", ")", "!=", "(", "size", "+", "8", "-", "1", ")", ">>", "3", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "size", ",", "len", "(", "data", ")", ")", "\n", "}", "\n\n", "bf", ".", "size", "=", "size", "\n", "bf", ".", "data", "=", "data", "\n", "return", "nil", "\n", "}" ]

[ "UnmarshalBinary", "implements", "encoding", ".", "BinaryUnmarshaler" ]

[ "func", "(", "bf", "*", "BitField", ")", "ToProperty", "(", ")", "(", "datastore", ".", "Property", ",", "error", ")", "{", "bs", ",", "err", ":=", "bf", ".", "MarshalBinary", "(", ")", "\n", "return", "datastore", ".", "MkPropertyNI", "(", "bs", ")", ",", "err", "\n", "}" ]

[ "ToProperty", "implements", "datastore", ".", "PropertyConverter" ]

[ "func", "Make", "(", "size", "uint32", ")", "BitField", "{", "if", "size", "==", "0", "{", "return", "BitField", "{", "}", "\n", "}", "\n", "return", "BitField", "{", "data", ":", "make", "(", "[", "]", "byte", ",", "(", "size", "+", "8", "-", "1", ")", ">>", "3", ")", ",", "size", ":", "size", ",", "}", "\n", "}" ]

[ "Make", "creates", "a", "new", "BitField", "." ]

[ "func", "(", "bf", "BitField", ")", "All", "(", "val", "bool", ")", "bool", "{", "targ", ":=", "bf", ".", "size", "\n", "if", "!", "val", "{", "targ", "=", "0", "\n", "}", "\n", "return", "bf", ".", "CountSet", "(", ")", "==", "targ", "\n", "}" ]

[ "All", "returns", "true", "iff", "all", "of", "the", "bits", "are", "equal", "to", "val", "." ]

[ "func", "(", "bf", "BitField", ")", "CountSet", "(", ")", "(", "ret", "uint32", ")", "{", "for", "_", ",", "b", ":=", "range", "bf", ".", "data", "{", "if", "b", "!=", "0", "{", "ret", "+=", "uint32", "(", "bitCount", "[", "b", "]", ")", "\n", "}", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "CountSet", "returns", "the", "number", "of", "true", "bits", "." ]

[ "func", "(", "bf", "BitField", ")", "IsSet", "(", "idx", "uint32", ")", "bool", "{", "return", "idx", "<", "bf", ".", "size", "&&", "(", "(", "bf", ".", "data", "[", "idx", ">>", "3", "]", "&", "(", "1", "<<", "(", "idx", "%", "8", ")", ")", ")", "!=", "0", ")", "\n", "}" ]

[ "IsSet", "returns", "the", "value", "of", "a", "given", "bit", "." ]

[ "func", "(", "ctl", "*", "Controller", ")", "tq", "(", ")", "*", "tq", ".", "Dispatcher", "{", "ctl", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "ctl", ".", "m", ".", "RUnlock", "(", ")", "\n", "if", "ctl", ".", "disp", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "ctl", ".", "disp", "\n", "}" ]

[ "tq", "returns", "a", "dispatcher", "set", "in", "Install", "or", "panics", "if", "not", "set", "yet", ".", "Grabs", "the", "reader", "lock", "inside", "." ]

[ "func", "(", "ctl", "*", "Controller", ")", "getFactory", "(", "id", "ID", ")", "(", "Factory", ",", "error", ")", "{", "ctl", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "ctl", ".", "m", ".", "RUnlock", "(", ")", "\n", "if", "m", ",", "ok", ":=", "ctl", ".", "mappers", "[", "id", "]", ";", "ok", "{", "return", "m", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "Reason", "(", "\"", "\"", ",", "id", ")", ".", "Err", "(", ")", "\n", "}" ]

[ "getFactory", "returns", "a", "registered", "mapper", "factory", "or", "an", "error", ".", "Grabs", "the", "reader", "lock", "inside", ".", "Can", "return", "only", "fatal", "errors", "." ]

[ "func", "(", "ctl", "*", "Controller", ")", "initMapper", "(", "c", "context", ".", "Context", ",", "j", "*", "Job", ",", "shardIdx", "int", ")", "(", "Mapper", ",", "error", ")", "{", "f", ",", "err", ":=", "ctl", ".", "getFactory", "(", "j", ".", "Config", ".", "Mapper", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "m", ",", "err", ":=", "f", "(", "c", ",", "j", ",", "shardIdx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "j", ".", "Config", ".", "Mapper", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "m", ",", "nil", "\n", "}" ]

[ "initMapper", "instantiates", "a", "Mapper", "through", "a", "registered", "factory", ".", "May", "return", "fatal", "and", "transient", "errors", "." ]

[ "func", "(", "ctl", "*", "Controller", ")", "GetJob", "(", "c", "context", ".", "Context", ",", "id", "JobID", ")", "(", "*", "Job", ",", "error", ")", "{", "// Even though we could have made getJob public, we want to force API users", "// to use Controller as a single facade.", "return", "getJob", "(", "c", ",", "id", ")", "\n", "}" ]

[ "GetJob", "fetches", "a", "previously", "launched", "job", "given", "its", "ID", ".", "Returns", "ErrNoSuchJob", "if", "not", "found", ".", "All", "other", "possible", "errors", "are", "transient", "and", "they", "are", "marked", "as", "such", "." ]

[ "func", "(", "ctl", "*", "Controller", ")", "AbortJob", "(", "c", "context", ".", "Context", ",", "id", "JobID", ")", "(", "job", "*", "Job", ",", "err", "error", ")", "{", "err", "=", "runTxn", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "var", "err", "error", "\n", "switch", "job", ",", "err", "=", "getJob", "(", "c", ",", "id", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "err", "\n", "case", "isFinalState", "(", "job", ".", "State", ")", "||", "job", ".", "State", "==", "State_ABORTING", ":", "return", "nil", "// nothing to abort, already done", "\n", "case", "job", ".", "State", "==", "State_STARTING", ":", "// Shards haven't been launched yet. Kill the job right away.", "job", ".", "State", "=", "State_ABORTED", "\n", "case", "job", ".", "State", "==", "State_RUNNING", ":", "// Running shards will discover that the job is aborting and will", "// eventually move into ABORTED state (notifying the job about it). Once", "// all shards report they are done, the job itself will switch into", "// ABORTED state.", "job", ".", "State", "=", "State_ABORTING", "\n", "}", "\n", "job", ".", "Updated", "=", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", "\n", "return", "errors", ".", "Annotate", "(", "datastore", ".", "Put", "(", "c", ",", "job", ")", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "job", "=", "nil", "// don't return bogus data in case txn failed to land", "\n", "}", "\n", "return", "\n", "}" ]

[ "AbortJob", "aborts", "a", "job", "and", "returns", "its", "most", "recent", "state", ".", "Silently", "does", "nothing", "if", "the", "job", "is", "finished", "or", "already", "aborted", ".", "Returns", "ErrNoSuchJob", "is", "there", "s", "no", "such", "job", "at", "all", ".", "All", "other", "possible", "errors", "are", "transient", "and", "they", "are", "marked", "as", "such", "." ]

[ "func", "(", "ctl", "*", "Controller", ")", "fanOutShardsHandler", "(", "c", "context", ".", "Context", ",", "payload", "proto", ".", "Message", ")", "error", "{", "msg", ":=", "payload", ".", "(", "*", "tasks", ".", "FanOutShards", ")", "\n\n", "// Make sure the job is still present. If it is aborted, we still need to", "// launch the shards, so they notice they are being aborted. We could try", "// to abort all shards right here and now, but it basically means implementing", "// an alternative shard abort flow. Seems simpler just to let the regular flow", "// to proceed.", "job", ",", "err", ":=", "getJobInState", "(", "c", ",", "JobID", "(", "msg", ".", "JobId", ")", ",", "State_RUNNING", ",", "State_ABORTING", ")", "\n", "if", "err", "!=", "nil", "||", "job", "==", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Grab the list of shards created in SplitAndLaunch. It must exist at this", "// point, since the job is in Running state.", "shardIDs", ",", "err", ":=", "job", ".", "fetchShardIDs", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Enqueue a bunch of named ProcessShard tasks (one per shard) to actually", "// launch shard processing. This is idempotent operation, so if FanOutShards", "// crashes midway and later retried, nothing bad happens.", "tsks", ":=", "make", "(", "[", "]", "*", "tq", ".", "Task", ",", "len", "(", "shardIDs", ")", ")", "\n", "for", "idx", ",", "sid", ":=", "range", "shardIDs", "{", "tsks", "[", "idx", "]", "=", "makeProcessShardTask", "(", "job", ".", "ID", ",", "sid", ",", "0", ",", "true", ")", "\n", "}", "\n", "return", "ctl", ".", "tq", "(", ")", ".", "AddTask", "(", "c", ",", "tsks", "...", ")", "\n", "}" ]

[ "fanOutShardsHandler", "fetches", "a", "list", "of", "shards", "from", "the", "job", "and", "launches", "named", "ProcessShard", "tasks", "one", "per", "shard", "." ]

[ "func", "(", "ctl", "*", "Controller", ")", "requestJobStateUpdate", "(", "c", "context", ".", "Context", ",", "jobID", "JobID", ",", "shardID", "int64", ")", "error", "{", "return", "ctl", ".", "tq", "(", ")", ".", "AddTask", "(", "c", ",", "&", "tq", ".", "Task", "{", "Title", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "jobID", ",", "shardID", ")", ",", "Payload", ":", "&", "tasks", ".", "RequestJobStateUpdate", "{", "JobId", ":", "int64", "(", "jobID", ")", ",", "ShardId", ":", "shardID", ",", "}", ",", "}", ")", "\n", "}" ]

[ "requestJobStateUpdate", "submits", "RequestJobStateUpdate", "task", "which", "eventually", "causes", "updateJobStateHandler", "to", "execute", "." ]

[ "func", "(", "ctl", "*", "Controller", ")", "updateJobStateHandler", "(", "c", "context", ".", "Context", ",", "payload", "proto", ".", "Message", ")", "error", "{", "msg", ":=", "payload", ".", "(", "*", "tasks", ".", "UpdateJobState", ")", "\n\n", "// Get the job and all its shards in their most recent state.", "job", ",", "err", ":=", "getJobInState", "(", "c", ",", "JobID", "(", "msg", ".", "JobId", ")", ",", "State_RUNNING", ",", "State_ABORTING", ")", "\n", "if", "err", "!=", "nil", "||", "job", "==", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "shards", ",", "err", ":=", "job", ".", "fetchShards", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Switch the job into a final state only when all shards are done running.", "perState", ":=", "make", "(", "map", "[", "State", "]", "int", ",", "len", "(", "State_name", ")", ")", "\n", "finished", ":=", "0", "\n", "for", "_", ",", "sh", ":=", "range", "shards", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "sh", ".", "Index", ",", "sh", ".", "ID", ",", "sh", ".", "State", ")", "\n", "perState", "[", "sh", ".", "State", "]", "++", "\n", "if", "isFinalState", "(", "sh", ".", "State", ")", "{", "finished", "++", "\n", "}", "\n", "}", "\n", "if", "finished", "!=", "len", "(", "shards", ")", "{", "return", "nil", "\n", "}", "\n\n", "jobState", ":=", "State_SUCCESS", "\n", "switch", "{", "case", "perState", "[", "State_ABORTED", "]", "!=", "0", ":", "jobState", "=", "State_ABORTED", "\n", "case", "perState", "[", "State_FAIL", "]", "!=", "0", ":", "jobState", "=", "State_FAIL", "\n", "}", "\n\n", "return", "runTxn", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "job", ",", "err", ":=", "getJobInState", "(", "c", ",", "JobID", "(", "msg", ".", "JobId", ")", ",", "State_RUNNING", ",", "State_ABORTING", ")", "\n", "if", "err", "!=", "nil", "||", "job", "==", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Make sure an aborting job ends up in aborted state, even if all its", "// shards manged to finish. It looks weird when an ABORTING job moves", "// into e.g. SUCCESS state.", "if", "job", ".", "State", "==", "State_ABORTING", "{", "job", ".", "State", "=", "State_ABORTED", "\n", "}", "else", "{", "job", ".", "State", "=", "jobState", "\n", "}", "\n", "job", ".", "Updated", "=", "clock", ".", "Now", "(", "c", ")", ".", "UTC", "(", ")", "\n\n", "runtime", ":=", "job", ".", "Updated", ".", "Sub", "(", "job", ".", "Created", ")", "\n", "switch", "job", ".", "State", "{", "case", "State_SUCCESS", ":", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "runtime", ")", "\n", "case", "State_FAIL", ":", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "perState", "[", "State_FAIL", "]", ",", "runtime", ")", "\n", "for", "_", ",", "sh", ":=", "range", "shards", "{", "if", "sh", ".", "State", "==", "State_FAIL", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "sh", ".", "Index", ",", "sh", ".", "ID", ",", "sh", ".", "Error", ")", "\n", "}", "\n", "}", "\n", "case", "State_ABORTED", ":", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "runtime", ",", "perState", "[", "State_SUCCESS", "]", ",", "perState", "[", "State_FAIL", "]", ",", "perState", "[", "State_ABORTED", "]", ")", "\n", "}", "\n\n", "return", "transient", ".", "Tag", ".", "Apply", "(", "datastore", ".", "Put", "(", "c", ",", "job", ")", ")", "\n", "}", ")", "\n", "}" ]

[ "updateJobStateHandler", "is", "called", "some", "time", "later", "after", "one", "or", "more", "shards", "have", "changed", "state", ".", "It", "calculates", "overall", "job", "state", "based", "on", "the", "state", "of", "its", "shards", "." ]

[ "func", "injectEnumValues", "(", "d", "starlark", ".", "StringDict", ",", "enum", "*", "descpb", ".", "EnumDescriptorProto", ")", "{", "for", "_", ",", "val", ":=", "range", "enum", ".", "Value", "{", "d", "[", "val", ".", "GetName", "(", ")", "]", "=", "starlark", ".", "MakeInt", "(", "int", "(", "val", ".", "GetNumber", "(", ")", ")", ")", "\n", "}", "\n", "}" ]

[ "injectEnumValues", "takes", "enum", "constants", "defined", "in", "enum", "and", "puts", "them", "directly", "into", "the", "given", "dict", "as", "integers", "." ]

[ "func", "loadFileDesc", "(", "name", "string", ")", "(", "*", "descpb", ".", "FileDescriptorProto", ",", "error", ")", "{", "gzblob", ":=", "proto", ".", "FileDescriptor", "(", "name", ")", "\n", "if", "gzblob", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "r", ",", "err", ":=", "gzip", ".", "NewReader", "(", "bytes", ".", "NewReader", "(", "gzblob", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "defer", "r", ".", "Close", "(", ")", "\n\n", "b", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "fd", ":=", "&", "descpb", ".", "FileDescriptorProto", "{", "}", "\n", "if", "err", ":=", "proto", ".", "Unmarshal", "(", "b", ",", "fd", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "fd", ",", "nil", "\n", "}" ]

[ "loadFileDesc", "loads", "a", "FileDescriptorProto", "for", "a", "given", "proto", "module", "specified", "by", "its", "full", "path", ".", "The", "module", "should", "be", "registered", "in", "the", "process", "s", "protobuf", "descriptors", "set", "." ]

[ "func", "signURL", "(", "c", "context", ".", "Context", ",", "gsPath", "string", ",", "signer", "*", "signer", ",", "expiry", "time", ".", "Duration", ")", "(", "string", ",", "error", ")", "{", "// See https://cloud.google.com/storage/docs/access-control/signed-urls.", "//", "// Basically, we sign a specially crafted multi-line string that encodes", "// expected parameters of the request. During the actual request, Google", "// Storage backend will construct the same string and verify that the provided", "// signature matches it.", "expires", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "clock", ".", "Now", "(", "c", ")", ".", "Add", "(", "expiry", ")", ".", "Unix", "(", ")", ")", "\n\n", "buf", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "fmt", ".", "Fprintf", "(", "buf", ",", "\"", "\\n", "\"", ")", "\n", "fmt", ".", "Fprintf", "(", "buf", ",", "\"", "\\n", "\"", ")", "// expected value of 'Content-MD5' header, not used", "\n", "fmt", ".", "Fprintf", "(", "buf", ",", "\"", "\\n", "\"", ")", "// expected value of 'Content-Type' header, not used", "\n", "fmt", ".", "Fprintf", "(", "buf", ",", "\"", "\\n", "\"", ",", "expires", ")", "\n", "fmt", ".", "Fprintf", "(", "buf", ",", "\"", "\"", ",", "gsPath", ")", "\n\n", "_", ",", "sig", ",", "err", ":=", "signer", ".", "SignBytes", "(", "c", ",", "buf", ".", "Bytes", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "u", ":=", "url", ".", "URL", "{", "Scheme", ":", "\"", "\"", ",", "Host", ":", "\"", "\"", ",", "Path", ":", "gsPath", ",", "RawQuery", ":", "(", "url", ".", "Values", "{", "\"", "\"", ":", "{", "signer", ".", "Email", "}", ",", "\"", "\"", ":", "{", "expires", "}", ",", "\"", "\"", ":", "{", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "sig", ")", "}", ",", "}", ")", ".", "Encode", "(", ")", ",", "}", "\n", "return", "u", ".", "String", "(", ")", ",", "nil", "\n", "}" ]

[ "signURL", "generates", "a", "signed", "GS", "URL", "using", "the", "signer", "." ]