Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "validateRef", "(", "ctx", "*", "validation", ".", "Context", ",", "configSet", ",", "path", "string", ",", "content", "[", "]", "byte", ")", "error", "{", "ctx", ".", "SetFile", "(", "path", ")", "\n", "// cq.cfg has been disallowed since Feb 1, 2019.", "// keep this error in place till Apr 1, 2019, to encourage clients remove this", "// config file from their repo.", "ctx", ".", "Errorf", "(", "\"", "\"", ")", "\n", "ctx", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "validateRefCfg", "validates", "legacy", "ref", "-", "specific", "cq", ".", "cfg", ".", "Validation", "result", "is", "returned", "via", "validation", "ctx", "while", "error", "returned", "directly", "implies", "only", "a", "bug", "in", "this", "code", "." ]

[ "func", "validateProject", "(", "ctx", "*", "validation", ".", "Context", ",", "configSet", ",", "path", "string", ",", "content", "[", "]", "byte", ")", "error", "{", "ctx", ".", "SetFile", "(", "path", ")", "\n", "cfg", ":=", "v2", ".", "Config", "{", "}", "\n", "if", "err", ":=", "proto", ".", "UnmarshalText", "(", "string", "(", "content", ")", ",", "&", "cfg", ")", ";", "err", "!=", "nil", "{", "ctx", ".", "Error", "(", "err", ")", "\n", "}", "else", "{", "validateProjectConfig", "(", "ctx", ",", "&", "cfg", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "validateProjectCfg", "validates", "project", "-", "level", "cq", ".", "cfg", ".", "Validation", "result", "is", "returned", "via", "validation", "ctx", "while", "error", "returned", "directly", "implies", "only", "a", "bug", "in", "this", "code", "." ]

[ "func", "bestEffortDisjointGroups", "(", "ctx", "*", "validation", ".", "Context", ",", "cfg", "*", "v2", ".", "Config", ")", "{", "defaultRefRegexps", ":=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "// Multimap gerrit URL => project => refRegexp => config group index.", "seen", ":=", "map", "[", "refKey", "]", "int", "{", "}", "\n\n", "for", "grIdx", ",", "gr", ":=", "range", "cfg", ".", "ConfigGroups", "{", "for", "gIdx", ",", "g", ":=", "range", "gr", ".", "Gerrit", "{", "for", "pIdx", ",", "p", ":=", "range", "g", ".", "Projects", "{", "refRegexps", ":=", "p", ".", "RefRegexp", "\n", "if", "len", "(", "p", ".", "RefRegexp", ")", "==", "0", "{", "refRegexps", "=", "defaultRefRegexps", "\n", "}", "\n", "for", "rIdx", ",", "refRegexp", ":=", "range", "refRegexps", "{", "if", "seenIdx", ",", "aliasing", ":=", "seen", "[", "refKey", "{", "g", ".", "Url", ",", "p", ".", "Name", ",", "refRegexp", "}", "]", ";", "!", "aliasing", "{", "seen", "[", "refKey", "{", "g", ".", "Url", ",", "p", ".", "Name", ",", "refRegexp", "}", "]", "=", "grIdx", "\n", "}", "else", "if", "seenIdx", "!=", "grIdx", "{", "// NOTE: we have already emitted error on duplicate gerrit URL,", "// project name, or ref_regexp within their own respective", "// container, so only error here is cases when these span multiple", "// config_groups.", "ctx", ".", "Enter", "(", "\"", "\"", ",", "grIdx", "+", "1", ")", "\n", "ctx", ".", "Enter", "(", "\"", "\"", ",", "gIdx", "+", "1", ")", "\n", "ctx", ".", "Enter", "(", "\"", "\"", ",", "pIdx", "+", "1", ")", "\n", "ctx", ".", "Enter", "(", "\"", "\"", ",", "rIdx", "+", "1", ")", "\n", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "seenIdx", "+", "1", ")", "\n", "ctx", ".", "Exit", "(", ")", "\n", "ctx", ".", "Exit", "(", ")", "\n", "ctx", ".", "Exit", "(", ")", "\n", "ctx", ".", "Exit", "(", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Second type of heuristics: match individual refs which are typically in", "// use, and check if they match against >1 configs.", "plainRefs", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "// Multimap gerrit url => project => plainRef => list of config_group indexes", "// matching this plainRef.", "matchedBy", ":=", "map", "[", "refKey", "]", "[", "]", "int", "{", "}", "\n", "for", "ref", ",", "seenIdx", ":=", "range", "seen", "{", "// Only check valid regexps here.", "if", "re", ",", "err", ":=", "regexp", ".", "Compile", "(", "\"", "\"", "+", "ref", ".", "refStr", "+", "\"", "\"", ")", ";", "err", "==", "nil", "{", "for", "_", ",", "plainRef", ":=", "range", "plainRefs", "{", "if", "re", ".", "MatchString", "(", "plainRef", ")", "{", "plainRefKey", ":=", "refKey", "{", "ref", ".", "url", ",", "ref", ".", "project", ",", "plainRef", "}", "\n", "matchedBy", "[", "plainRefKey", "]", "=", "append", "(", "matchedBy", "[", "plainRefKey", "]", ",", "seenIdx", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "for", "ref", ",", "matchedIdxs", ":=", "range", "matchedBy", "{", "if", "len", "(", "matchedIdxs", ")", ">", "1", "{", "sort", ".", "Slice", "(", "matchedIdxs", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "matchedIdxs", "[", "i", "]", "<", "matchedIdxs", "[", "j", "]", "}", ")", "\n", "ctx", ".", "Errorf", "(", "\"", "\"", ",", "ref", ".", "url", ",", "ref", ".", "project", ",", "ref", ".", "refStr", ",", "matchedIdxs", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "bestEffortDisjointGroups", "errors", "out", "on", "easy", "to", "spot", "overlaps", "between", "configGroups", ".", "It", "is", "non", "-", "trivial", "if", "it", "all", "possible", "to", "ensure", "that", "regexp", "across", "config_groups", "don", "t", "overlap", ".", "But", "we", "can", "catch", "typical", "copy", "-", "pasta", "mistakes", "early", "on", "by", "checking", "for", "equality", "of", "regexps", "." ]

[ "func", "ProjectFromNamespace", "(", "ns", "string", ")", "types", ".", "ProjectName", "{", "if", "!", "strings", ".", "HasPrefix", "(", "ns", ",", "ProjectNamespacePrefix", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "types", ".", "ProjectName", "(", "ns", "[", "len", "(", "ProjectNamespacePrefix", ")", ":", "]", ")", "\n", "}" ]

[ "ProjectFromNamespace", "returns", "the", "current", "project", "installed", "in", "the", "supplied", "Context", "s", "namespace", ".", "If", "the", "namespace", "does", "not", "have", "a", "project", "namespace", "prefix", "this", "function", "will", "return", "an", "empty", "string", "." ]

[ "func", "CurrentProject", "(", "c", "context", ".", "Context", ")", "types", ".", "ProjectName", "{", "if", "ns", ":=", "info", ".", "GetNamespace", "(", "c", ")", ";", "ns", "!=", "\"", "\"", "{", "return", "ProjectFromNamespace", "(", "ns", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "CurrentProject", "returns", "the", "current", "project", "based", "on", "the", "currently", "-", "loaded", "namespace", ".", "If", "there", "is", "no", "current", "namespace", "or", "if", "the", "current", "namespace", "is", "not", "a", "valid", "project", "namespace", "an", "empty", "string", "will", "be", "returned", "." ]

[ "func", "CurrentProjectConfig", "(", "c", "context", ".", "Context", ")", "(", "*", "svcconfig", ".", "ProjectConfig", ",", "error", ")", "{", "return", "GetConfigProvider", "(", "c", ")", ".", "ProjectConfig", "(", "c", ",", "CurrentProject", "(", "c", ")", ")", "\n", "}" ]

[ "CurrentProjectConfig", "returns", "the", "project", "-", "specific", "configuration", "for", "the", "current", "project", ".", "If", "there", "is", "no", "current", "project", "namespace", "or", "if", "the", "current", "project", "has", "no", "configuration", "config", ".", "ErrInvalidConfig", "will", "be", "returned", "." ]

[ "func", "(", "r", "*", "DeadlineReader", ")", "SetReadTimeout", "(", "d", "time", ".", "Duration", ")", "error", "{", "r", ".", "Deadline", "=", "d", "\n", "return", "nil", "\n", "}" ]

[ "SetReadTimeout", "implements", "ReadDeadlineSetter", "." ]

[ "func", "ValidateTag", "(", "k", ",", "v", "string", ")", "error", "{", "if", "err", ":=", "StreamName", "(", "k", ")", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "len", "(", "k", ")", ">", "MaxTagKeySize", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "k", ")", ",", "MaxTagKeySize", ")", "\n", "}", "\n", "if", "len", "(", "v", ")", ">", "MaxTagValueSize", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "v", ")", ",", "MaxTagValueSize", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidateTag", "returns", "an", "error", "if", "a", "tag", "contains", "a", "nonconfirming", "value", "." ]

[ "func", "(", "*", "Service", ")", "CreateNIC", "(", "c", "context", ".", "Context", ",", "req", "*", "crimson", ".", "CreateNICRequest", ")", "(", "*", "crimson", ".", "NIC", ",", "error", ")", "{", "if", "err", ":=", "createNIC", "(", "c", ",", "req", ".", "Nic", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "req", ".", "Nic", ",", "nil", "\n", "}" ]

[ "CreateNIC", "handles", "a", "request", "to", "create", "a", "new", "network", "interface", "." ]

[ "func", "(", "*", "Service", ")", "DeleteNIC", "(", "c", "context", ".", "Context", ",", "req", "*", "crimson", ".", "DeleteNICRequest", ")", "(", "*", "empty", ".", "Empty", ",", "error", ")", "{", "if", "err", ":=", "deleteNIC", "(", "c", ",", "req", ".", "Name", ",", "req", ".", "Machine", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "empty", ".", "Empty", "{", "}", ",", "nil", "\n", "}" ]

[ "DeleteNIC", "handles", "a", "request", "to", "delete", "an", "existing", "network", "interface", "." ]

[ "func", "(", "*", "Service", ")", "ListNICs", "(", "c", "context", ".", "Context", ",", "req", "*", "crimson", ".", "ListNICsRequest", ")", "(", "*", "crimson", ".", "ListNICsResponse", ",", "error", ")", "{", "nics", ",", "err", ":=", "listNICs", "(", "c", ",", "database", ".", "Get", "(", "c", ")", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "crimson", ".", "ListNICsResponse", "{", "Nics", ":", "nics", ",", "}", ",", "nil", "\n", "}" ]

[ "ListNICs", "handles", "a", "request", "to", "list", "network", "interfaces", "." ]

[ "func", "(", "*", "Service", ")", "UpdateNIC", "(", "c", "context", ".", "Context", ",", "req", "*", "crimson", ".", "UpdateNICRequest", ")", "(", "*", "crimson", ".", "NIC", ",", "error", ")", "{", "return", "updateNIC", "(", "c", ",", "req", ".", "Nic", ",", "req", ".", "UpdateMask", ")", "\n", "}" ]

[ "UpdateNIC", "handles", "a", "request", "to", "update", "an", "existing", "network", "interface", "." ]

[ "func", "createNIC", "(", "c", "context", ".", "Context", ",", "n", "*", "crimson", ".", "NIC", ")", "error", "{", "if", "err", ":=", "validateNICForCreation", "(", "n", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "mac", ",", "_", ":=", "common", ".", "ParseMAC48", "(", "n", ".", "MacAddress", ")", "\n", "tx", ",", "err", ":=", "database", ".", "Begin", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "tx", ".", "MaybeRollback", "(", "c", ")", "\n\n", "var", "hostnameId", "sql", ".", "NullInt64", "\n", "if", "n", ".", "Hostname", "!=", "\"", "\"", "{", "ip", ",", "_", ":=", "common", ".", "ParseIPv4", "(", "n", ".", "Ipv4", ")", "\n", "id", ",", "err", ":=", "model", ".", "AssignHostnameAndIP", "(", "c", ",", "tx", ",", "n", ".", "Hostname", ",", "ip", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "hostnameId", ".", "Int64", "=", "id", "\n", "hostnameId", ".", "Valid", "=", "true", "\n", "}", "\n\n", "// By setting nics.machine_id NOT NULL when setting up the database, we can avoid checking if the given machine is", "// valid. MySQL will turn up NULL for its column values which will be rejected as an error.", "_", ",", "err", "=", "tx", ".", "ExecContext", "(", "c", ",", "`\n\t\tINSERT INTO nics (name, machine_id, mac_address, switch_id, switchport, hostname_id)\n\t\tVALUES (?, (SELECT id FROM machines WHERE name = ?), ?, (SELECT id FROM switches WHERE name = ?), ?, ?)\n\t`", ",", "n", ".", "Name", ",", "n", ".", "Machine", ",", "mac", ",", "n", ".", "Switch", ",", "n", ".", "Switchport", ",", "hostnameId", ")", "\n", "if", "err", "!=", "nil", "{", "switch", "e", ",", "ok", ":=", "err", ".", "(", "*", "mysql", ".", "MySQLError", ")", ";", "{", "case", "!", "ok", ":", "// Type assertion failed.", "case", "e", ".", "Number", "==", "mysqlerr", ".", "ER_DUP_ENTRY", "&&", "strings", ".", "Contains", "(", "e", ".", "Message", ",", "\"", "\"", ")", ":", "// e.g. \"Error 1062: Duplicate entry 'eth0-machineId' for key 'name'\".", "return", "status", ".", "Errorf", "(", "codes", ".", "AlreadyExists", ",", "\"", "\"", ",", "n", ".", "Name", ",", "n", ".", "Machine", ")", "\n", "case", "e", ".", "Number", "==", "mysqlerr", ".", "ER_DUP_ENTRY", "&&", "strings", ".", "Contains", "(", "e", ".", "Message", ",", "\"", "\"", ")", ":", "// e.g. \"Error 1062: Duplicate entry '1234567890' for key 'mac_address'\".", "return", "status", ".", "Errorf", "(", "codes", ".", "AlreadyExists", ",", "\"", "\"", ",", "n", ".", "MacAddress", ")", "\n", "case", "e", ".", "Number", "==", "mysqlerr", ".", "ER_BAD_NULL_ERROR", "&&", "strings", ".", "Contains", "(", "e", ".", "Message", ",", "\"", "\"", ")", ":", "// e.g. \"Error 1048: Column 'machine_id' cannot be null\".", "return", "status", ".", "Errorf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ",", "n", ".", "Machine", ")", "\n", "case", "e", ".", "Number", "==", "mysqlerr", ".", "ER_BAD_NULL_ERROR", "&&", "strings", ".", "Contains", "(", "e", ".", "Message", ",", "\"", "\"", ")", ":", "// e.g. \"Error 1048: Column 'switch_id' cannot be null\".", "return", "status", ".", "Errorf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ",", "n", ".", "Switch", ")", "\n", "}", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "if", "err", ":=", "tx", ".", "Commit", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "createNIC", "creates", "a", "new", "NIC", "in", "the", "database", "." ]

[ "func", "getHostnameForNIC", "(", "c", "context", ".", "Context", ",", "q", "database", ".", "QueryerContext", ",", "name", ",", "machine", "string", ")", "(", "*", "int64", ",", "error", ")", "{", "rows", ",", "err", ":=", "q", ".", "QueryContext", "(", "c", ",", "`\n\t\tSELECT h.id FROM nics n, machines m, hostnames h\n\t\tWHERE n.machine_id = m.id AND n.hostname_id = h.id AND n.name = ? AND m.name = ?\n\t`", ",", "name", ",", "machine", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n", "if", "rows", ".", "Next", "(", ")", "{", "var", "hostnameId", "int64", "\n", "if", "err", "=", "rows", ".", "Scan", "(", "&", "hostnameId", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "&", "hostnameId", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "getHostnameForNIC", "gets", "the", "ID", "of", "the", "hostname", "associated", "with", "an", "existing", "NIC", "." ]

[ "func", "deleteNIC", "(", "c", "context", ".", "Context", ",", "name", ",", "machine", "string", ")", "error", "{", "switch", "{", "case", "name", "==", "\"", "\"", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "machine", "==", "\"", "\"", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n", "tx", ",", "err", ":=", "database", ".", "Begin", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "tx", ".", "MaybeRollback", "(", "c", ")", "\n\n", "// If a NIC is backing a host, don't delete it. If not, delete it and its hostname (if it has one).", "// Deleting a hostname cascades to the host, so hostname can't be deleted without first checking", "// for a host. Deleting a hostname sets null in the NIC, so the NIC still has to be deleted.", "hosts", ",", "err", ":=", "listPhysicalHosts", "(", "c", ",", "tx", ",", "&", "crimson", ".", "ListPhysicalHostsRequest", "{", "Machines", ":", "[", "]", "string", "{", "machine", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "len", "(", "hosts", ")", ">", "0", "{", "return", "status", ".", "Errorf", "(", "codes", ".", "FailedPrecondition", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Delete the NIC's hostname, if it has one.", "hostnameId", ",", "err", ":=", "getHostnameForNIC", "(", "c", ",", "tx", ",", "name", ",", "machine", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "hostnameId", "!=", "nil", "{", "_", ",", "err", "=", "tx", ".", "ExecContext", "(", "c", ",", "`DELETE FROM hostnames WHERE id = ?`", ",", "*", "hostnameId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n\n", "res", ",", "err", ":=", "tx", ".", "ExecContext", "(", "c", ",", "`\n\t\tDELETE FROM nics WHERE name = ? AND machine_id = (SELECT id FROM machines WHERE name = ?)\n\t`", ",", "name", ",", "machine", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "switch", "rows", ",", "err", ":=", "res", ".", "RowsAffected", "(", ")", ";", "{", "case", "err", "!=", "nil", ":", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "case", "rows", "==", "0", ":", "return", "status", ".", "Errorf", "(", "codes", ".", "NotFound", ",", "\"", "\"", ",", "name", ",", "machine", ")", "\n", "}", "\n\n", "if", "err", ":=", "tx", ".", "Commit", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "deleteNIC", "deletes", "an", "existing", "NIC", "from", "the", "database", "." ]

[ "func", "listNICs", "(", "c", "context", ".", "Context", ",", "q", "database", ".", "QueryerContext", ",", "req", "*", "crimson", ".", "ListNICsRequest", ")", "(", "[", "]", "*", "crimson", ".", "NIC", ",", "error", ")", "{", "mac48s", ",", "err", ":=", "parseMAC48s", "(", "req", ".", "MacAddresses", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "stmt", ":=", "squirrel", ".", "Select", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", ".", "From", "(", "\"", "\"", ")", ".", "Where", "(", "\"", "\"", ")", ".", "Where", "(", "\"", "\"", ")", "\n", "stmt", "=", "selectInString", "(", "stmt", ",", "\"", "\"", ",", "req", ".", "Names", ")", "\n", "stmt", "=", "selectInString", "(", "stmt", ",", "\"", "\"", ",", "req", ".", "Machines", ")", "\n", "stmt", "=", "selectInUint64", "(", "stmt", ",", "\"", "\"", ",", "mac48s", ")", "\n", "stmt", "=", "selectInString", "(", "stmt", ",", "\"", "\"", ",", "req", ".", "Switches", ")", "\n", "query", ",", "args", ",", "err", ":=", "stmt", ".", "ToSql", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "rows", ",", "err", ":=", "q", ".", "QueryContext", "(", "c", ",", "query", ",", "args", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n", "var", "nics", "[", "]", "*", "crimson", ".", "NIC", "\n", "for", "rows", ".", "Next", "(", ")", "{", "n", ":=", "&", "crimson", ".", "NIC", "{", "}", "\n", "var", "mac48", "common", ".", "MAC48", "\n", "if", "err", "=", "rows", ".", "Scan", "(", "&", "n", ".", "Name", ",", "&", "n", ".", "Machine", ",", "&", "mac48", ",", "&", "n", ".", "Switch", ",", "&", "n", ".", "Switchport", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "n", ".", "MacAddress", "=", "mac48", ".", "String", "(", ")", "\n", "nics", "=", "append", "(", "nics", ",", "n", ")", "\n", "}", "\n", "return", "nics", ",", "nil", "\n", "}" ]

[ "listNICs", "returns", "a", "slice", "of", "NICs", "in", "the", "database", "." ]

[ "func", "parseMAC48s", "(", "macs", "[", "]", "string", ")", "(", "[", "]", "uint64", ",", "error", ")", "{", "mac48s", ":=", "make", "(", "[", "]", "uint64", ",", "len", "(", "macs", ")", ")", "\n", "for", "i", ",", "mac", ":=", "range", "macs", "{", "mac48", ",", "err", ":=", "common", ".", "ParseMAC48", "(", "mac", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "mac", ")", "\n", "}", "\n", "mac48s", "[", "i", "]", "=", "uint64", "(", "mac48", ")", "\n", "}", "\n", "return", "mac48s", ",", "nil", "\n", "}" ]

[ "parseMAC48s", "returns", "a", "slice", "of", "uint64", "MAC", "addresses", "." ]

[ "func", "validateNICForCreation", "(", "n", "*", "crimson", ".", "NIC", ")", "error", "{", "switch", "{", "case", "n", "==", "nil", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "n", ".", "Name", "==", "\"", "\"", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "n", ".", "Machine", "==", "\"", "\"", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "n", ".", "Switch", "==", "\"", "\"", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "n", ".", "Switchport", "<", "1", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "default", ":", "// If hostname or IPv4 address is specified, require both.", "if", "n", ".", "Hostname", "!=", "\"", "\"", "||", "n", ".", "Ipv4", "!=", "\"", "\"", "{", "if", "n", ".", "Hostname", "==", "\"", "\"", "{", "return", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "n", ".", "Ipv4", "==", "\"", "\"", "{", "return", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n", "_", ",", "err", ":=", "common", ".", "ParseIPv4", "(", "n", ".", "Ipv4", ")", "\n", "if", "err", "!=", "nil", "{", "return", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "n", ".", "Ipv4", ")", "\n", "}", "\n", "}", "\n", "_", ",", "err", ":=", "common", ".", "ParseMAC48", "(", "n", ".", "MacAddress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "n", ".", "MacAddress", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "validateNICForCreation", "validates", "a", "NIC", "for", "creation", "." ]

[ "func", "validateNICForUpdate", "(", "n", "*", "crimson", ".", "NIC", ",", "mask", "*", "field_mask", ".", "FieldMask", ")", "error", "{", "switch", "err", ":=", "validateUpdateMask", "(", "mask", ")", ";", "{", "case", "n", "==", "nil", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "n", ".", "Name", "==", "\"", "\"", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "n", ".", "Machine", "==", "\"", "\"", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "err", "!=", "nil", ":", "return", "err", "\n", "}", "\n", "for", "_", ",", "path", ":=", "range", "mask", ".", "Paths", "{", "// TODO(smut): Allow hostname, IPv4 address to be updated.", "switch", "path", "{", "case", "\"", "\"", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "\"", "\"", ":", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "case", "\"", "\"", ":", "if", "n", ".", "MacAddress", "==", "\"", "\"", "{", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n", "_", ",", "err", ":=", "common", ".", "ParseMAC48", "(", "n", ".", "MacAddress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "n", ".", "MacAddress", ")", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "n", ".", "Switch", "==", "\"", "\"", "{", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "n", ".", "Switchport", "<", "1", "{", "return", "status", ".", "Error", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "status", ".", "Errorf", "(", "codes", ".", "InvalidArgument", ",", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "validateNICForUpdate", "validates", "a", "NIC", "for", "update", "." ]

[ "func", "searchBuilds", "(", "ctx", "context", ".", "Context", ",", "buildC", "chan", "<-", "*", "pb", ".", "Build", ",", "client", "pb", ".", "BuildsClient", ",", "req", "*", "pb", ".", "SearchBuildsRequest", ")", "error", "{", "// Prepare a channel of responses, s.t. we make an RPC as soon as we started", "// consuming the response, as opposed to after the response is completely", "// consumed.", "resC", ":=", "make", "(", "chan", "*", "pb", ".", "SearchBuildsResponse", ")", "\n", "errC", ":=", "make", "(", "chan", "error", ")", "\n", "go", "func", "(", ")", "{", "err", ":=", "searchResponses", "(", "ctx", ",", "resC", ",", "client", ",", "req", ")", "\n", "close", "(", "resC", ")", "\n", "errC", "<-", "err", "\n", "}", "(", ")", "\n\n", "// Forward builds.", "for", "res", ":=", "range", "resC", "{", "for", "_", ",", "b", ":=", "range", "res", ".", "Builds", "{", "select", "{", "case", "buildC", "<-", "b", ":", "// Note: selecting on errC here would be a race because goroutine", "// above might have been already done, but we still did not send", "// all builds to the caller.", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "<-", "errC", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "<-", "errC", "\n", "}" ]

[ "searchBuilds", "is", "like", "Search", "but", "does", "not", "implement", "union", "of", "search", "results", ".", "Sent", "builds", "have", "ids", "." ]

[ "func", "searchResponses", "(", "ctx", "context", ".", "Context", ",", "resC", "chan", "<-", "*", "pb", ".", "SearchBuildsResponse", ",", "client", "pb", ".", "BuildsClient", ",", "req", "*", "pb", ".", "SearchBuildsRequest", ")", "error", "{", "req", "=", "proto", ".", "Clone", "(", "req", ")", ".", "(", "*", "pb", ".", "SearchBuildsRequest", ")", "\n\n", "// Ensure next_page_token and build id are requested.", "if", "len", "(", "req", ".", "GetFields", "(", ")", ".", "GetPaths", "(", ")", ")", ">", "0", "{", "req", ".", "Fields", ".", "Paths", "=", "append", "(", "req", ".", "Fields", ".", "Paths", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Page through results.", "for", "{", "res", ",", "err", ":=", "client", ".", "SearchBuilds", "(", "ctx", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "select", "{", "case", "resC", "<-", "res", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n\n", "if", "res", ".", "NextPageToken", "==", "\"", "\"", "||", "len", "(", "res", ".", "Builds", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// Next page...", "req", ".", "PageToken", "=", "res", ".", "NextPageToken", "\n", "}", "\n", "}" ]

[ "searchResponses", "pages", "through", "search", "results", "and", "sends", "search", "responses", "to", "resC", ".", "Builds", "in", "resC", "have", "ids", "." ]

[ "func", "(", "h", "streamHeap", ")", "Swap", "(", "i", ",", "j", "int", ")", "{", "h", "[", "i", "]", ",", "h", "[", "j", "]", "=", "h", "[", "j", "]", ",", "h", "[", "i", "]", "\n", "}" ]

[ "Swap", "implements", "sort", ".", "Interface", "." ]

[ "func", "(", "h", "*", "streamHeap", ")", "Pop", "(", ")", "interface", "{", "}", "{", "old", ":=", "*", "h", "\n", "n", ":=", "len", "(", "old", ")", "\n", "x", ":=", "old", "[", "n", "-", "1", "]", "\n", "*", "h", "=", "old", "[", "0", ":", "n", "-", "1", "]", "\n", "return", "x", "\n", "}" ]

[ "Pop", "implements", "heap", ".", "Interface", "." ]

[ "func", "(", "s", "State", ")", "Name", "(", ")", "string", "{", "switch", "s", "{", "case", "State_STATE_UNSPECIFIED", ":", "return", "\"", "\"", "\n", "case", "State_FREE", ":", "return", "\"", "\"", "\n", "case", "State_PRERELEASE", ":", "return", "\"", "\"", "\n", "case", "State_SERVING", ":", "return", "\"", "\"", "\n", "case", "State_TEST", ":", "return", "\"", "\"", "\n", "case", "State_REPAIR", ":", "return", "\"", "\"", "\n", "case", "State_DECOMMISSIONED", ":", "return", "\"", "\"", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "Name", "returns", "a", "string", "which", "can", "be", "used", "as", "the", "human", "-", "readable", "representation", "expected", "by", "GetState", "." ]

[ "func", "GetState", "(", "s", "string", ")", "(", "State", ",", "error", ")", "{", "lower", ":=", "strings", ".", "ToLower", "(", "s", ")", "\n", "switch", "{", "case", "lower", "==", "\"", "\"", ":", "return", "State_STATE_UNSPECIFIED", ",", "nil", "\n", "case", "strings", ".", "HasPrefix", "(", "\"", "\"", ",", "lower", ")", ":", "return", "State_FREE", ",", "nil", "\n", "case", "strings", ".", "HasPrefix", "(", "\"", "\"", ",", "lower", ")", ":", "return", "State_PRERELEASE", ",", "nil", "\n", "case", "strings", ".", "HasPrefix", "(", "\"", "\"", ",", "lower", ")", ":", "return", "State_SERVING", ",", "nil", "\n", "case", "strings", ".", "HasPrefix", "(", "\"", "\"", ",", "lower", ")", ":", "return", "State_TEST", ",", "nil", "\n", "case", "strings", ".", "HasPrefix", "(", "\"", "\"", ",", "lower", ")", ":", "return", "State_REPAIR", ",", "nil", "\n", "case", "strings", ".", "HasPrefix", "(", "\"", "\"", ",", "lower", ")", ":", "return", "State_DECOMMISSIONED", ",", "nil", "\n", "default", ":", "return", "-", "1", ",", "errors", ".", "Reason", "(", "\"", "\"", ",", "s", ")", ".", "Err", "(", ")", "\n", "}", "\n", "}" ]

[ "GetState", "returns", "a", "State", "given", "its", "name", ".", "Supports", "prefix", "matching", "." ]

[ "func", "(", "p", "*", "PackageDef", ")", "Expand", "(", "expander", "template", ".", "Expander", ")", "(", "pkg", "string", ",", "err", "error", ")", "{", "switch", "pkg", ",", "err", "=", "expander", ".", "Expand", "(", "p", ".", "PackageTemplate", ")", ";", "{", "case", "err", "==", "template", ".", "ErrSkipTemplate", ":", "return", "\"", "\"", ",", "err", "\n", "case", "err", "!=", "nil", ":", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "p", ".", "LineNo", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "err", "=", "common", ".", "ValidatePackageName", "(", "pkg", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "p", ".", "LineNo", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "err", "=", "common", ".", "ValidateInstanceVersion", "(", "p", ".", "UnresolvedVersion", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "p", ".", "LineNo", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Expand", "expands", "the", "package", "name", "template", "and", "checks", "that", "resulting", "package", "name", "and", "version", "are", "syntactically", "correct", ".", "May", "return", "template", ".", "ErrSkipTemplate", "is", "this", "package", "definition", "should", "be", "skipped", "given", "the", "current", "expansion", "variables", "values", "." ]

[ "func", "shardItems", "(", "items", "[", "]", "*", "Item", ",", "threshold", "int64", ")", "[", "]", "*", "itemBundle", "{", "// For deterministic isolated hashes, sort the items by path.", "sort", ".", "Sort", "(", "itemByPath", "(", "items", ")", ")", "\n\n", "var", "bundles", "[", "]", "*", "itemBundle", "\n", "for", "len", "(", "items", ")", ">", "0", "{", "var", "bundle", "*", "itemBundle", "\n", "bundle", ",", "items", "=", "oneBundle", "(", "items", ",", "threshold", ")", "\n", "bundles", "=", "append", "(", "bundles", ",", "bundle", ")", "\n", "}", "\n", "return", "bundles", "\n", "}" ]

[ "shardItems", "shards", "the", "provided", "items", "into", "itemBundles", "using", "the", "provided", "threshold", "as", "the", "maximum", "size", "the", "resultant", "tars", "should", "be", ".", "shardItems", "does", "not", "access", "the", "filesystem", "." ]

[ "func", "(", "b", "*", "itemBundle", ")", "Digest", "(", "h", "crypto", ".", "Hash", ")", "(", "isolated", ".", "HexDigest", ",", "int64", ",", "error", ")", "{", "a", ":=", "h", ".", "New", "(", ")", "\n", "cw", ":=", "&", "iotools", ".", "CountingWriter", "{", "Writer", ":", "a", "}", "\n", "if", "err", ":=", "b", ".", "writeTar", "(", "cw", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "0", ",", "err", "\n", "}", "\n", "return", "isolated", ".", "Sum", "(", "a", ")", ",", "cw", ".", "Count", ",", "nil", "\n", "}" ]

[ "Digest", "returns", "the", "hash", "and", "total", "size", "of", "the", "tar", "constructed", "from", "the", "bundle", "s", "items", "." ]

[ "func", "(", "b", "*", "itemBundle", ")", "Contents", "(", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "pr", ",", "pw", ":=", "io", ".", "Pipe", "(", ")", "\n", "go", "func", "(", ")", "{", "pw", ".", "CloseWithError", "(", "b", ".", "writeTar", "(", "pw", ")", ")", "\n", "}", "(", ")", "\n", "return", "pr", ",", "nil", "\n", "}" ]

[ "Contents", "returns", "an", "io", ".", "ReadCloser", "containing", "the", "tar", "s", "contents", "." ]

[ "func", "(", "r", "*", "renderedFrame", ")", "dumpWrappersTo", "(", "w", "io", ".", "Writer", ",", "from", ",", "to", "int", ")", "(", "n", "int", ",", "err", "error", ")", "{", "return", "iotools", ".", "WriteTracker", "(", "w", ",", "func", "(", "rawWriter", "io", ".", "Writer", ")", "error", "{", "w", ":=", "&", "indented", ".", "Writer", "{", "Writer", ":", "rawWriter", ",", "UseSpaces", ":", "true", "}", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "from", ",", "to", ")", "\n", "for", "i", ",", "wrp", ":=", "range", "r", ".", "wrappers", "{", "if", "i", "!=", "0", "{", "w", ".", "Write", "(", "nlSlice", ")", "\n", "}", "\n", "w", ".", "Level", "=", "2", "\n", "for", "i", ",", "line", ":=", "range", "wrp", "{", "if", "i", "==", "0", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "line", ")", "\n", "w", ".", "Level", "+=", "2", "\n", "}", "else", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "line", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "dumpWrappersTo", "formats", "the", "wrappers", "portion", "of", "this", "renderedFrame", "." ]

[ "func", "(", "r", "*", "renderedFrame", ")", "dumpTo", "(", "w", "io", ".", "Writer", ",", "idx", "int", ")", "(", "n", "int", ",", "err", "error", ")", "{", "return", "iotools", ".", "WriteTracker", "(", "w", ",", "func", "(", "rawWriter", "io", ".", "Writer", ")", "error", "{", "w", ":=", "&", "indented", ".", "Writer", "{", "Writer", ":", "rawWriter", ",", "UseSpaces", ":", "true", "}", "\n\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "idx", ",", "r", ".", "pkg", ",", "r", ".", "file", ",", "r", ".", "lineNum", ",", "r", ".", "funcName", ")", "\n", "w", ".", "Level", "+=", "2", "\n", "switch", "len", "(", "r", ".", "annotations", ")", "{", "case", "0", ":", "// pass", "case", "1", ":", "for", "_", ",", "line", ":=", "range", "r", ".", "annotations", "[", "0", "]", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "line", ")", "\n", "}", "\n", "default", ":", "for", "i", ",", "ann", ":=", "range", "r", ".", "annotations", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "i", ")", "\n", "w", ".", "Level", "+=", "2", "\n", "for", "_", ",", "line", ":=", "range", "ann", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "line", ")", "\n", "}", "\n", "w", ".", "Level", "-=", "2", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "dumpTo", "formats", "the", "Header", "and", "annotations", "for", "this", "renderedFrame", "." ]

[ "func", "(", "r", "*", "renderedStack", ")", "dumpTo", "(", "w", "io", ".", "Writer", ",", "excludePkgs", "...", "string", ")", "(", "n", "int", ",", "err", "error", ")", "{", "excludeSet", ":=", "stringset", ".", "NewFromSlice", "(", "excludePkgs", "...", ")", "\n\n", "return", "iotools", ".", "WriteTracker", "(", "w", ",", "func", "(", "w", "io", ".", "Writer", ")", "error", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "r", ".", "goID", ")", "\n\n", "lastIdx", ":=", "0", "\n", "needNL", ":=", "false", "\n", "skipCount", ":=", "0", "\n", "skipPkg", ":=", "\"", "\"", "\n", "flushSkips", ":=", "func", "(", "extra", "string", ")", "{", "if", "skipCount", "!=", "0", "{", "if", "needNL", "{", "w", ".", "Write", "(", "nlSlice", ")", "\n", "needNL", "=", "false", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "skipCount", ",", "skipPkg", ",", "extra", ")", "\n", "skipCount", "=", "0", "\n", "skipPkg", "=", "\"", "\"", "\n", "}", "\n", "}", "\n", "for", "i", ",", "f", ":=", "range", "r", ".", "frames", "{", "if", "needNL", "{", "w", ".", "Write", "(", "nlSlice", ")", "\n", "needNL", "=", "false", "\n", "}", "\n", "if", "excludeSet", ".", "Has", "(", "f", ".", "pkg", ")", "{", "if", "skipPkg", "==", "f", ".", "pkg", "{", "skipCount", "++", "\n", "}", "else", "{", "flushSkips", "(", "\"", "\"", ")", "\n", "skipCount", "++", "\n", "skipPkg", "=", "f", ".", "pkg", "\n", "}", "\n", "continue", "\n", "}", "\n", "flushSkips", "(", "\"", "\\n", "\"", ")", "\n", "if", "len", "(", "f", ".", "wrappers", ")", ">", "0", "{", "f", ".", "dumpWrappersTo", "(", "w", ",", "lastIdx", ",", "i", ")", "\n", "w", ".", "Write", "(", "nlSlice", ")", "\n", "}", "\n", "if", "len", "(", "f", ".", "annotations", ")", ">", "0", "{", "lastIdx", "=", "i", "\n", "needNL", "=", "true", "\n", "}", "\n", "f", ".", "dumpTo", "(", "w", ",", "i", ")", "\n", "}", "\n", "flushSkips", "(", "\"", "\"", ")", "\n\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "dumpTo", "formats", "the", "full", "stack", "." ]

[ "func", "(", "r", "*", "renderedError", ")", "toLines", "(", "excludePkgs", "...", "string", ")", "lines", "{", "buf", ":=", "bytes", ".", "Buffer", "{", "}", "\n", "r", ".", "dumpTo", "(", "&", "buf", ",", "excludePkgs", "...", ")", "\n", "return", "strings", ".", "Split", "(", "strings", ".", "TrimSuffix", "(", "buf", ".", "String", "(", ")", ",", "\"", "\\n", "\"", ")", ",", "\"", "\\n", "\"", ")", "\n", "}" ]

[ "toLines", "renders", "a", "full", "-", "information", "stack", "trace", "as", "a", "series", "of", "lines", "." ]

[ "func", "(", "r", "*", "renderedError", ")", "dumpTo", "(", "w", "io", ".", "Writer", ",", "excludePkgs", "...", "string", ")", "(", "n", "int", ",", "err", "error", ")", "{", "return", "iotools", ".", "WriteTracker", "(", "w", ",", "func", "(", "w", "io", ".", "Writer", ")", "error", "{", "if", "r", ".", "originalError", "!=", "\"", "\"", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\\n", "\"", ",", "r", ".", "originalError", ")", "\n", "}", "\n\n", "for", "i", ":=", "len", "(", "r", ".", "stacks", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "if", "i", "!=", "len", "(", "r", ".", "stacks", ")", "-", "1", "{", "w", ".", "Write", "(", "nlSlice", ")", "\n", "}", "\n", "r", ".", "stacks", "[", "i", "]", ".", "dumpTo", "(", "w", ",", "excludePkgs", "...", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "dumpTo", "writes", "the", "full", "-", "information", "stack", "trace", "to", "the", "writer", "." ]

[ "func", "RenderStack", "(", "err", "error", ",", "excludePkgs", "...", "string", ")", "[", "]", "string", "{", "return", "renderStack", "(", "err", ")", ".", "toLines", "(", "excludePkgs", "...", ")", "\n", "}" ]

[ "RenderStack", "renders", "the", "error", "to", "a", "list", "of", "lines", "." ]

[ "func", "New", "(", "msg", "string", ",", "tags", "...", "TagValueGenerator", ")", "error", "{", "tse", ":=", "&", "terminalStackError", "{", "errors", ".", "New", "(", "msg", ")", ",", "stackFrameInfo", "{", "forStack", ":", "captureStack", "(", "1", ")", "}", ",", "nil", "}", "\n", "if", "len", "(", "tags", ")", ">", "0", "{", "tse", ".", "tags", "=", "make", "(", "map", "[", "TagKey", "]", "interface", "{", "}", ",", "len", "(", "tags", ")", ")", "\n", "for", "_", ",", "t", ":=", "range", "tags", "{", "v", ":=", "t", ".", "GenerateErrorTagValue", "(", ")", "\n", "tse", ".", "tags", "[", "v", ".", "Key", "]", "=", "v", ".", "Value", "\n", "}", "\n", "}", "\n", "return", "tse", "\n", "}" ]

[ "New", "is", "an", "API", "-", "compatible", "version", "of", "the", "standard", "errors", ".", "New", "function", ".", "Unlike", "the", "stdlib", "errors", ".", "New", "this", "will", "capture", "the", "current", "stack", "information", "at", "the", "place", "this", "error", "was", "created", "." ]

[ "func", "toTextPb", "(", "_", "*", "starlark", ".", "Thread", ",", "_", "*", "starlark", ".", "Builtin", ",", "args", "starlark", ".", "Tuple", ",", "kwargs", "[", "]", "starlark", ".", "Tuple", ")", "(", "starlark", ".", "Value", ",", "error", ")", "{", "var", "msg", "*", "Message", "\n", "if", "err", ":=", "starlark", ".", "UnpackArgs", "(", "\"", "\"", ",", "args", ",", "kwargs", ",", "\"", "\"", ",", "&", "msg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "pb", ",", "err", ":=", "msg", ".", "ToProto", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "starlark", ".", "String", "(", "proto", ".", "MarshalTextString", "(", "pb", ")", ")", ",", "nil", "\n", "}" ]

[ "toTextPb", "takes", "a", "single", "protobuf", "message", "and", "serializes", "it", "using", "text", "protobuf", "serialization", "." ]

[ "func", "toJSONPb", "(", "_", "*", "starlark", ".", "Thread", ",", "_", "*", "starlark", ".", "Builtin", ",", "args", "starlark", ".", "Tuple", ",", "kwargs", "[", "]", "starlark", ".", "Tuple", ")", "(", "starlark", ".", "Value", ",", "error", ")", "{", "var", "msg", "*", "Message", "\n", "var", "emitDefaults", "starlark", ".", "Bool", "\n", "if", "err", ":=", "starlark", ".", "UnpackArgs", "(", "\"", "\"", ",", "args", ",", "kwargs", ",", "\"", "\"", ",", "&", "msg", ",", "\"", "\"", ",", "&", "emitDefaults", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "pb", ",", "err", ":=", "msg", ".", "ToProto", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// More jsonpb Marshaler options may be added here as needed.", "var", "jsonMarshaler", "=", "&", "jsonpb", ".", "Marshaler", "{", "Indent", ":", "\"", "\\t", "\"", ",", "EmitDefaults", ":", "bool", "(", "emitDefaults", ")", "}", "\n", "str", ",", "err", ":=", "jsonMarshaler", ".", "MarshalToString", "(", "pb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "starlark", ".", "String", "(", "str", ")", ",", "nil", "\n", "}" ]

[ "toJSONPb", "takes", "a", "single", "protobuf", "message", "and", "serializes", "it", "using", "JSONPB", "serialization", "." ]

[ "func", "(", "p", "*", "BuildInfoProvider", ")", "GetBuildInfo", "(", "c", "context", ".", "Context", ",", "req", "*", "milo", ".", "BuildInfoRequest_Swarming", ",", "projectHint", "string", ")", "(", "*", "milo", ".", "BuildInfoResponse", ",", "error", ")", "{", "// Load the Swarming task (no log content).", "sf", ",", "err", ":=", "p", ".", "newSwarmingService", "(", "c", ",", "req", ".", "Host", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Internal", "\n", "}", "\n\n", "// Use default Swarming host.", "host", ":=", "sf", ".", "GetHost", "(", ")", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "host", ",", "req", ".", "Task", ")", "\n\n", "fr", ",", "err", ":=", "swarmingFetch", "(", "c", ",", "sf", ",", "req", ".", "Task", ",", "swarmingFetchParams", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "ErrNotMiloJob", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "NotFound", "\n", "}", "\n\n", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "Internal", "\n", "}", "\n\n", "// Determine the LogDog annotation stream path for this Swarming task.", "//", "// On failure, will return a gRPC error.", "stream", ",", "err", ":=", "resolveLogDogAnnotations", "(", "c", ",", "fr", ".", "res", ".", "Tags", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "logging", ".", "Fields", "{", "\"", "\"", ":", "stream", ".", "Host", ",", "\"", "\"", ":", "stream", ".", "Project", ",", "\"", "\"", ":", "stream", ".", "Path", ",", "}", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n\n", "step", ",", "err", ":=", "rawpresentation", ".", "ReadAnnotations", "(", "c", ",", "stream", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Add Swarming task parameters to the Milo step.", "if", "err", ":=", "addTaskToMiloStep", "(", "c", ",", "sf", ".", "GetHost", "(", ")", ",", "fr", ".", "res", ",", "step", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "prefix", ",", "name", ":=", "stream", ".", "Path", ".", "Split", "(", ")", "\n", "return", "&", "milo", ".", "BuildInfoResponse", "{", "Project", ":", "string", "(", "stream", ".", "Project", ")", ",", "Step", ":", "step", ",", "AnnotationStream", ":", "&", "miloProto", ".", "LogdogStream", "{", "Server", ":", "stream", ".", "Host", ",", "Prefix", ":", "string", "(", "prefix", ")", ",", "Name", ":", "string", "(", "name", ")", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "GetBuildInfo", "resolves", "a", "Milo", "protobuf", "Step", "for", "a", "given", "Swarming", "task", "." ]

[ "func", "resolveLogDogAnnotations", "(", "c", "context", ".", "Context", ",", "tagsRaw", "[", "]", "string", ")", "(", "*", "types", ".", "StreamAddr", ",", "error", ")", "{", "addr", ",", "err", ":=", "resolveLogDogStreamAddrFromTags", "(", "swarmingTags", "(", "tagsRaw", ")", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Debugf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "grpcutil", ".", "NotFound", "\n", "}", "\n", "return", "addr", ",", "nil", "\n", "}" ]

[ "resolveLogDogAnnotations", "returns", "a", "configured", "AnnotationStream", "given", "the", "input", "parameters", ".", "This", "will", "return", "a", "gRPC", "error", "on", "failure", "." ]

[ "func", "LoadX509Signer", "(", "privateKeyPath", ",", "certPath", "string", ")", "(", "*", "X509Signer", ",", "error", ")", "{", "pkey", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "privateKeyPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "cert", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "certPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "signer", ":=", "&", "X509Signer", "{", "PrivateKeyPEM", ":", "pkey", ",", "CertificatePEM", ":", "cert", ",", "}", "\n", "if", "err", "=", "signer", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "signer", ",", "nil", "\n", "}" ]

[ "LoadX509Signer", "parses", "and", "validates", "private", "key", "and", "certificate", "PEM", "files", ".", "Returns", "X509Signer", "that", "is", "ready", "for", "work", "." ]

[ "func", "(", "s", "*", "X509Signer", ")", "Algo", "(", "ctx", "context", ".", "Context", ")", "(", "x509", ".", "SignatureAlgorithm", ",", "error", ")", "{", "if", "err", ":=", "s", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "s", ".", "algo", ",", "nil", "\n", "}" ]

[ "Algo", "returns", "an", "algorithm", "that", "the", "signer", "implements", "." ]

[ "func", "(", "s", "*", "X509Signer", ")", "Certificate", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "err", ":=", "s", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "s", ".", "certDer", ",", "nil", "\n", "}" ]

[ "Certificate", "returns", "ASN", ".", "1", "DER", "blob", "with", "the", "certificate", "of", "the", "signer", "." ]

[ "func", "(", "s", "*", "X509Signer", ")", "Sign", "(", "ctx", "context", ".", "Context", ",", "blob", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "err", ":=", "s", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "hashFunc", "crypto", ".", "Hash", "\n", "switch", "s", ".", "algo", "{", "case", "x509", ".", "SHA256WithRSA", ":", "hashFunc", "=", "crypto", ".", "SHA256", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "h", ":=", "hashFunc", ".", "New", "(", ")", "\n", "h", ".", "Write", "(", "blob", ")", "\n", "digest", ":=", "h", ".", "Sum", "(", "nil", ")", "\n\n", "return", "s", ".", "pkey", ".", "Sign", "(", "cryptorand", ".", "Get", "(", "ctx", ")", ",", "digest", ",", "hashFunc", ")", "\n", "}" ]

[ "Sign", "signs", "a", "blob", "using", "the", "private", "key", "." ]

[ "func", "(", "s", "*", "X509Signer", ")", "Validate", "(", ")", "error", "{", "s", ".", "init", ".", "Do", "(", "func", "(", ")", "{", "s", ".", "err", "=", "s", ".", "initialize", "(", ")", "\n", "}", ")", "\n", "return", "s", ".", "err", "\n", "}" ]

[ "Validate", "parses", "the", "private", "key", "and", "certificate", "file", "and", "verifies", "them", ".", "It", "checks", "that", "the", "public", "portion", "of", "the", "key", "matches", "what", "s", "in", "the", "certificate", "." ]

[ "func", "getSummary", "(", "c", "context", ".", "Context", ",", "host", "string", ",", "project", "string", ",", "id", "int64", ")", "(", "*", "model", ".", "BuildSummary", ",", "error", ")", "{", "client", ",", "err", ":=", "buildbucketClient", "(", "c", ",", "host", ",", "auth", ".", "AsProject", ",", "auth", ".", "WithProject", "(", "project", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "b", ",", "err", ":=", "client", ".", "GetBuild", "(", "c", ",", "&", "buildbucketpb", ".", "GetBuildRequest", "{", "Id", ":", "id", ",", "Fields", ":", "summaryBuildMask", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "buildAddress", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Id", ")", "\n", "if", "b", ".", "Number", "!=", "0", "{", "buildAddress", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Builder", ".", "Project", ",", "b", ".", "Builder", ".", "Bucket", ",", "b", ".", "Builder", ".", "Builder", ",", "b", ".", "Number", ")", "\n", "}", "\n\n", "// Note: The parent for buildbucket build summaries is currently a fake entity.", "// In the future, builds can be cached here, but we currently don't do that.", "buildKey", ":=", "datastore", ".", "MakeKey", "(", "c", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "host", ",", "buildAddress", ")", ")", "\n", "swarming", ":=", "b", ".", "GetInfra", "(", ")", ".", "GetSwarming", "(", ")", "\n\n", "bs", ":=", "&", "model", ".", "BuildSummary", "{", "ProjectID", ":", "b", ".", "Builder", ".", "Project", ",", "BuildKey", ":", "buildKey", ",", "BuilderID", ":", "BuilderID", "{", "*", "b", ".", "Builder", "}", ".", "String", "(", ")", ",", "BuildID", ":", "\"", "\"", "+", "buildAddress", ",", "BuildSet", ":", "protoutil", ".", "BuildSets", "(", "b", ")", ",", "ContextURI", ":", "[", "]", "string", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "host", ",", "id", ")", "}", ",", "Created", ":", "mustTimestamp", "(", "b", ".", "CreateTime", ")", ",", "Summary", ":", "model", ".", "Summary", "{", "Start", ":", "mustTimestamp", "(", "b", ".", "StartTime", ")", ",", "End", ":", "mustTimestamp", "(", "b", ".", "EndTime", ")", ",", "Status", ":", "statusMap", "[", "b", ".", "Status", "]", ",", "}", ",", "Version", ":", "mustTimestamp", "(", "b", ".", "UpdateTime", ")", ".", "UnixNano", "(", ")", ",", "Experimental", ":", "b", ".", "GetInput", "(", ")", ".", "GetExperimental", "(", ")", ",", "}", "\n", "if", "task", ":=", "swarming", ".", "GetTaskId", "(", ")", ";", "task", "!=", "\"", "\"", "{", "bs", ".", "ContextURI", "=", "append", "(", "bs", ".", "ContextURI", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "swarming", ".", "GetHostname", "(", ")", ",", "swarming", ".", "GetTaskId", "(", ")", ")", ")", "\n", "}", "\n", "return", "bs", ",", "nil", "\n", "}" ]

[ "getSummary", "returns", "a", "model", ".", "BuildSummary", "representing", "a", "buildbucket", "build", "." ]

[ "func", "pubSubHandlerImpl", "(", "c", "context", ".", "Context", ",", "r", "*", "http", ".", "Request", ")", "error", "{", "// This is the default action. The code below will modify the values of some", "// or all of these parameters.", "isLUCI", ",", "bucket", ",", "status", ",", "action", ":=", "false", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "\n\n", "defer", "func", "(", ")", "{", "// closure for late binding", "buildCounter", ".", "Add", "(", "c", ",", "1", ",", "bucket", ",", "isLUCI", ",", "status", ",", "action", ")", "\n", "}", "(", ")", "\n\n", "msg", ":=", "common", ".", "PubSubSubscription", "{", "}", "\n", "if", "err", ":=", "json", ".", "NewDecoder", "(", "r", ".", "Body", ")", ".", "Decode", "(", "&", "msg", ")", ";", "err", "!=", "nil", "{", "// This might be a transient error, e.g. when the json format changes", "// and Milo isn't updated yet.", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Tag", "(", "transient", ".", "Tag", ")", ".", "Err", "(", ")", "\n", "}", "\n", "if", "v", ",", "ok", ":=", "msg", ".", "Message", ".", "Attributes", "[", "\"", "\"", "]", ".", "(", "string", ")", ";", "ok", "&&", "v", "!=", "\"", "\"", "{", "// TODO(nodir): switch to v2, crbug.com/826006", "logging", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "v", ")", "\n", "return", "nil", "\n", "}", "\n", "bData", ",", "err", ":=", "msg", ".", "GetData", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "event", ":=", "struct", "{", "Build", "bbv1", ".", "ApiCommonBuildMessage", "`json:\"build\"`", "\n", "Hostname", "string", "`json:\"hostname\"`", "\n", "}", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "bData", ",", "&", "event", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "build", ":=", "deprecated", ".", "Build", "{", "}", "\n", "if", "err", ":=", "build", ".", "ParseMessage", "(", "&", "event", ".", "Build", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "bucket", "=", "build", ".", "Bucket", "\n", "status", "=", "build", ".", "Status", ".", "String", "(", ")", "\n", "isLUCI", "=", "strings", ".", "HasPrefix", "(", "bucket", ",", "\"", "\"", ")", "\n\n", "logging", ".", "Debugf", "(", "c", ",", "\"", "\\n", "\"", ",", "event", ".", "Hostname", ",", "bucket", ",", "build", ".", "Builder", ",", "status", ",", "build", ")", "\n\n", "if", "!", "isLUCI", "||", "build", ".", "Builder", "==", "\"", "\"", "{", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// TODO(iannucci,nodir): get the bot context too", "// TODO(iannucci,nodir): support manifests/got_revision", "bs", ",", "err", ":=", "getSummary", "(", "c", ",", "event", ".", "Hostname", ",", "build", ".", "Project", ",", "build", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "bs", ".", "AddManifestKeysFromBuildSets", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "transient", ".", "Tag", ".", "Apply", "(", "datastore", ".", "RunInTransaction", "(", "c", ",", "func", "(", "c", "context", ".", "Context", ")", "error", "{", "curBS", ":=", "&", "model", ".", "BuildSummary", "{", "BuildKey", ":", "bs", ".", "BuildKey", "}", "\n", "switch", "err", ":=", "datastore", ".", "Get", "(", "c", ",", "curBS", ")", ";", "err", "{", "case", "datastore", ".", "ErrNoSuchEntity", ":", "action", "=", "\"", "\"", "\n", "case", "nil", ":", "action", "=", "\"", "\"", "\n", "default", ":", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "if", "bs", ".", "Version", "<=", "curBS", ".", "Version", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "bs", ".", "Version", ",", "curBS", ".", "Version", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "err", ":=", "datastore", ".", "Put", "(", "c", ",", "bs", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "model", ".", "UpdateBuilderForBuild", "(", "c", ",", "bs", ")", "\n", "}", ",", "&", "datastore", ".", "TransactionOptions", "{", "XG", ":", "true", "}", ")", ")", "\n", "}" ]

[ "pubSubHandlerImpl", "takes", "the", "http", ".", "Request", "expects", "to", "find", "a", "common", ".", "PubSubSubscription", "JSON", "object", "in", "the", "Body", "containing", "a", "bbPSEvent", "and", "handles", "the", "contents", "with", "generateSummary", "." ]

[ "func", "MakeBuildKey", "(", "c", "context", ".", "Context", ",", "host", ",", "buildAddress", "string", ")", "*", "datastore", ".", "Key", "{", "return", "datastore", ".", "MakeKey", "(", "c", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "host", ",", "buildAddress", ")", ")", "\n", "}" ]

[ "MakeBuildKey", "returns", "a", "new", "datastore", "Key", "for", "a", "buildbucket", ".", "Build", ".", "There", "s", "currently", "no", "model", "associated", "with", "this", "key", "but", "it", "s", "used", "as", "a", "parent", "for", "a", "model", ".", "BuildSummary", "." ]

[ "func", "WithConfigProvider", "(", "c", "context", ".", "Context", ",", "s", "ConfigProvider", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "c", ",", "&", "configProviderKey", ",", "s", ")", "\n", "}" ]

[ "WithConfigProvider", "installs", "the", "supplied", "ConfigProvider", "instance", "into", "a", "Context", "." ]

[ "func", "Project", "(", "c", "context", ".", "Context", ")", "types", ".", "ProjectName", "{", "ns", ":=", "info", ".", "GetNamespace", "(", "c", ")", "\n", "project", ":=", "ProjectFromNamespace", "(", "ns", ")", "\n", "if", "project", "!=", "\"", "\"", "{", "return", "project", "\n", "}", "\n", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ns", ",", "ProjectNamespacePrefix", ")", ")", "\n", "}" ]

[ "Project", "returns", "the", "current", "project", "installed", "in", "the", "supplied", "Context", "s", "namespace", ".", "This", "function", "is", "called", "with", "the", "expectation", "that", "the", "Context", "is", "in", "a", "namespace", "conforming", "to", "ProjectNamespace", ".", "If", "this", "is", "not", "the", "case", "this", "method", "will", "panic", "." ]

[ "func", "(", "e", "*", "Executor", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "command", "[", "]", "string", ")", "error", "{", "// Clear any previous state.", "e", ".", "executed", "=", "false", "\n", "e", ".", "returnCode", "=", "0", "\n", "e", ".", "step", "=", "nil", "\n\n", "if", "len", "(", "command", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ctx", ",", "cancelFunc", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "command", "[", "0", "]", ",", "command", "[", "1", ":", "]", "...", ")", "\n\n", "// STDOUT", "stdoutRC", ",", "err", ":=", "cmd", ".", "StdoutPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "defer", "stdoutRC", ".", "Close", "(", ")", "\n", "stdout", ":=", "e", ".", "configStream", "(", "stdoutRC", ",", "annotee", ".", "STDOUT", ",", "e", ".", "TeeStdout", ",", "true", ")", "\n\n", "stderrRC", ",", "err", ":=", "cmd", ".", "StderrPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "defer", "stderrRC", ".", "Close", "(", ")", "\n", "stderr", ":=", "e", ".", "configStream", "(", "stderrRC", ",", "annotee", ".", "STDERR", ",", "e", ".", "TeeStderr", ",", "false", ")", "\n\n", "// Start our process.", "if", "err", ":=", "cmd", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Cleanup the process on exit, and record its status and return code.", "defer", "func", "(", ")", "{", "if", "err", ":=", "cmd", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "var", "ok", "bool", "\n", "if", "e", ".", "returnCode", ",", "ok", "=", "exitcode", ".", "Get", "(", "err", ")", ";", "ok", "{", "e", ".", "executed", "=", "true", "\n", "}", "else", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "{", "e", ".", "returnCode", "=", "0", "\n", "e", ".", "executed", "=", "true", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Probe our execution information.", "options", ":=", "e", ".", "Options", "\n", "if", "options", ".", "Execution", "==", "nil", "{", "options", ".", "Execution", "=", "annotation", ".", "ProbeExecution", "(", "command", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Configure our Processor.", "streams", ":=", "[", "]", "*", "annotee", ".", "Stream", "{", "stdout", ",", "stderr", ",", "}", "\n\n", "// Process the bootstrapped I/O. We explicitly defer a Finish here to ensure", "// that we clean up any internal streams if our Processor fails/panics.", "//", "// If we fail to process the I/O, terminate the bootstrapped process", "// immediately, since it may otherwise block forever on I/O.", "proc", ":=", "annotee", ".", "New", "(", "ctx", ",", "options", ")", "\n", "defer", "proc", ".", "Finish", "(", ")", "\n\n", "if", "err", ":=", "proc", ".", "RunStreams", "(", "streams", ")", ";", "err", "!=", "nil", "{", "cancelFunc", "(", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Finish and record our annotation steps on completion.", "if", "e", ".", "step", ",", "err", "=", "proto", ".", "Marshal", "(", "proc", ".", "Finish", "(", ")", ".", "RootStep", "(", ")", ".", "Proto", "(", ")", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Run", "executes", "the", "bootstrapped", "process", "blocking", "until", "it", "completes", "." ]

[ "func", "Unwrap", "(", "err", "error", ")", "error", "{", "for", "{", "wrap", ",", "ok", ":=", "err", ".", "(", "Wrapped", ")", "\n", "if", "!", "ok", "{", "return", "err", "\n", "}", "\n\n", "inner", ":=", "wrap", ".", "InnerError", "(", ")", "\n", "if", "inner", "==", "nil", "{", "break", "\n", "}", "\n", "err", "=", "inner", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Unwrap", "unwraps", "a", "wrapped", "error", "recursively", "returning", "its", "inner", "error", ".", "If", "the", "supplied", "error", "is", "not", "nil", "Unwrap", "will", "never", "return", "nil", ".", "If", "a", "wrapped", "error", "reports", "that", "its", "InnerError", "is", "nil", "that", "error", "will", "be", "returned", "." ]

[ "func", "getDatabaseConnection", "(", "c", "context", ".", "Context", ")", "(", "*", "sql", ".", "DB", ",", "error", ")", "{", "// Update the database pointer if the database settings have changed. This operation is costly, but should be rare.", "// Done here to ensure that a connection established with an outdated connection string is closed as soon as possible.", "settings", ",", "err", ":=", "settings", ".", "Get", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "connectionString", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "settings", ".", "Username", ",", "settings", ".", "Password", ",", "settings", ".", "Server", ",", "settings", ".", "Database", ")", "\n\n", "// If the connection string matches what we expect, the current pointer is correct so just return it.", "dbLock", ".", "RLock", "(", ")", "\n", "if", "connectionString", "==", "dbConnectionString", "{", "defer", "dbLock", ".", "RUnlock", "(", ")", "\n", "return", "db", ",", "nil", "\n", "}", "\n", "dbLock", ".", "RUnlock", "(", ")", "\n\n", "// The connection string doesn't match so the db pointer needs to be created or updated.", "dbLock", ".", "Lock", "(", ")", "\n", "defer", "dbLock", ".", "Unlock", "(", ")", "\n\n", "// Releasing the read lock may have allowed another concurrent request to grab the write lock first so it's", "// possible we no longer need to do anything. Check again while holding the write lock.", "if", "connectionString", "==", "dbConnectionString", "{", "return", "db", ",", "nil", "\n", "}", "\n\n", "if", "db", "!=", "nil", "{", "if", "err", ":=", "db", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "logging", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n", "db", ",", "err", "=", "sql", ".", "Open", "(", "\"", "\"", ",", "connectionString", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "// AppEngine limit.", "db", ".", "SetMaxOpenConns", "(", "12", ")", "\n", "dbConnectionString", "=", "connectionString", "\n", "return", "db", ",", "nil", "\n", "}" ]

[ "getDatabaseConnection", "returns", "a", "pointer", "to", "the", "open", "database", "connection", "creating", "it", "if", "necessary", "." ]

[ "func", "Begin", "(", "c", "context", ".", "Context", ")", "(", "*", "RollbackTx", ",", "error", ")", "{", "tx", ",", "err", ":=", "Get", "(", "c", ")", ".", "BeginTx", "(", "c", ",", "nil", ")", "\n", "return", "&", "RollbackTx", "{", "Tx", ":", "tx", "}", ",", "err", "\n", "}" ]

[ "Begin", "begins", "a", "transaction", "using", "the", "database", "pointer", "embedded", "in", "the", "current", "context", "." ]

[ "func", "Get", "(", "c", "context", ".", "Context", ")", "*", "sql", ".", "DB", "{", "return", "c", ".", "Value", "(", "&", "dbKey", ")", ".", "(", "*", "sql", ".", "DB", ")", "\n", "}" ]

[ "Get", "returns", "the", "database", "pointer", "embedded", "in", "the", "current", "context", ".", "The", "database", "pointer", "can", "be", "embedded", "in", "the", "current", "context", "using", "With", "." ]

[ "func", "With", "(", "c", "context", ".", "Context", ",", "database", "*", "sql", ".", "DB", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "c", ",", "&", "dbKey", ",", "database", ")", "\n", "}" ]

[ "With", "installs", "a", "database", "pointer", "into", "the", "given", "context", ".", "It", "can", "be", "retrieved", "later", "using", "Get", "." ]

[ "func", "WithMiddleware", "(", "c", "*", "router", ".", "Context", ",", "next", "router", ".", "Handler", ")", "{", "database", ",", "err", ":=", "getDatabaseConnection", "(", "c", ".", "Context", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "Errorf", "(", "c", ".", "Context", ",", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "c", ".", "Writer", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "c", ".", "Writer", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "return", "\n", "}", "\n", "c", ".", "Context", "=", "With", "(", "c", ".", "Context", ",", "database", ")", "\n", "next", "(", "c", ")", "\n", "}" ]

[ "WithMiddleware", "is", "middleware", "which", "installs", "a", "database", "pointer", "into", "the", "given", "context", ".", "It", "can", "be", "retrieved", "later", "in", "the", "middleware", "chain", "using", "Get", "." ]

[ "func", "RunnerMain", "(", "args", "[", "]", "string", ")", "int", "{", "if", "err", ":=", "mainErr", "(", "args", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "err", ")", "\n", "return", "1", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "RunnerMain", "runs", "LUCI", "runner", "a", "program", "that", "runs", "a", "LUCI", "executable", "." ]

[ "func", "(", "as", "*", "AnnotationStream", ")", "Normalize", "(", ")", "error", "{", "if", "err", ":=", "as", ".", "Project", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "as", ".", "Project", ")", ".", "Tag", "(", "grpcutil", ".", "InvalidArgumentTag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "if", "err", ":=", "as", ".", "Path", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "as", ".", "Path", ")", ".", "Tag", "(", "grpcutil", ".", "InvalidArgumentTag", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Normalize", "validates", "and", "normalizes", "the", "stream", "s", "parameters", "." ]

[ "func", "(", "as", "*", "AnnotationStream", ")", "Fetch", "(", "c", "context", ".", "Context", ")", "(", "*", "miloProto", ".", "Step", ",", "error", ")", "{", "// Cached?", "if", "as", ".", "cs", ".", "Step", "!=", "nil", "{", "return", "as", ".", "cs", ".", "Step", ",", "nil", "\n", "}", "\n\n", "// Load from LogDog directly.", "log", ".", "Fields", "{", "\"", "\"", ":", "as", ".", "Client", ".", "Host", ",", "\"", "\"", ":", "as", ".", "Project", ",", "\"", "\"", ":", "as", ".", "Path", ",", "}", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n\n", "var", "(", "state", "coordinator", ".", "LogStream", "\n", "stream", "=", "as", ".", "Client", ".", "Stream", "(", "as", ".", "Project", ",", "as", ".", "Path", ")", "\n", ")", "\n\n", "le", ",", "err", ":=", "stream", ".", "Tail", "(", "c", ",", "coordinator", ".", "WithState", "(", "&", "state", ")", ",", "coordinator", ".", "Complete", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Make sure that this is an annotation stream.", "switch", "{", "case", "state", ".", "Desc", ".", "ContentType", "!=", "miloProto", ".", "ContentTypeAnnotations", ":", "return", "nil", ",", "errNotMilo", "\n\n", "case", "state", ".", "Desc", ".", "StreamType", "!=", "logpb", ".", "StreamType_DATAGRAM", ":", "return", "nil", ",", "errNotDatagram", "\n\n", "case", "le", "==", "nil", ":", "// No annotation stream data, so render a minimal page.", "return", "nil", ",", "errNoEntries", "\n", "}", "\n\n", "// Get the last log entry in the stream. In reality, this will be index 0,", "// since the \"Tail\" call should only return one log entry.", "//", "// Because we supplied the \"Complete\" flag to Tail and suceeded, this datagram", "// will be complete even if its source datagram(s) are fragments.", "dg", ":=", "le", ".", "GetDatagram", "(", ")", "\n", "if", "dg", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Attempt to decode the Step protobuf.", "var", "step", "miloProto", ".", "Step", "\n", "if", "err", ":=", "proto", ".", "Unmarshal", "(", "dg", ".", "Data", ",", "&", "step", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "latestEndedTime", "time", ".", "Time", "\n", "for", "_", ",", "sub", ":=", "range", "step", ".", "Substep", "{", "switch", "t", ":=", "sub", ".", "Substep", ".", "(", "type", ")", "{", "case", "*", "miloProto", ".", "Step_Substep_AnnotationStream", ":", "// TODO(hinoka,dnj): Implement recursive / embedded substream fetching if", "// specified.", "log", ".", "Warningf", "(", "c", ",", "\"", "\"", ",", "t", ".", "AnnotationStream", ")", "\n\n", "case", "*", "miloProto", ".", "Step_Substep_Step", ":", "endedTime", ":=", "google", ".", "TimeFromProto", "(", "t", ".", "Step", ".", "Ended", ")", "\n", "if", "t", ".", "Step", ".", "Ended", "!=", "nil", "&&", "endedTime", ".", "After", "(", "latestEndedTime", ")", "{", "latestEndedTime", "=", "endedTime", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "latestEndedTime", ".", "IsZero", "(", ")", "{", "// No substep had an ended time :(", "latestEndedTime", "=", "google", ".", "TimeFromProto", "(", "step", ".", "Started", ")", "\n", "}", "\n\n", "// Build our CachedStep.", "as", ".", "cs", "=", "internal", ".", "CachedStep", "{", "Step", ":", "&", "step", ",", "Finished", ":", "(", "state", ".", "State", ".", "TerminalIndex", ">=", "0", "&&", "le", ".", "StreamIndex", "==", "uint64", "(", "state", ".", "State", ".", "TerminalIndex", ")", ")", ",", "}", "\n", "return", "as", ".", "cs", ".", "Step", ",", "nil", "\n", "}" ]

[ "Fetch", "loads", "the", "annotation", "stream", "from", "LogDog", ".", "If", "the", "stream", "does", "not", "exist", "or", "is", "invalid", "Fetch", "will", "return", "a", "Milo", "error", ".", "Otherwise", "it", "will", "return", "the", "Step", "that", "was", "loaded", ".", "Fetch", "caches", "the", "step", "so", "multiple", "calls", "to", "Fetch", "will", "return", "the", "same", "Step", "value", "." ]

[ "func", "NewURLBuilder", "(", "addr", "*", "types", ".", "StreamAddr", ")", "*", "ViewerURLBuilder", "{", "prefix", ",", "_", ":=", "addr", ".", "Path", ".", "Split", "(", ")", "\n", "return", "&", "ViewerURLBuilder", "{", "Host", ":", "addr", ".", "Host", ",", "Prefix", ":", "prefix", ",", "Project", ":", "addr", ".", "Project", ",", "}", "\n", "}" ]

[ "NewURLBuilder", "creates", "a", "new", "URLBuilder", "that", "can", "generate", "links", "to", "LogDog", "pages", "given", "a", "LogDog", "StreamAddr", "." ]

[ "func", "(", "b", "*", "ViewerURLBuilder", ")", "BuildLink", "(", "l", "*", "miloProto", ".", "Link", ")", "*", "ui", ".", "Link", "{", "switch", "t", ":=", "l", ".", "Value", ".", "(", "type", ")", "{", "case", "*", "miloProto", ".", "Link_LogdogStream", ":", "ls", ":=", "t", ".", "LogdogStream", "\n\n", "server", ":=", "ls", ".", "Server", "\n", "if", "server", "==", "\"", "\"", "{", "server", "=", "b", ".", "Host", "\n", "}", "\n\n", "prefix", ":=", "types", ".", "StreamName", "(", "ls", ".", "Prefix", ")", "\n", "if", "prefix", "==", "\"", "\"", "{", "prefix", "=", "b", ".", "Prefix", "\n", "}", "\n\n", "u", ":=", "viewer", ".", "GetURL", "(", "server", ",", "b", ".", "Project", ",", "prefix", ".", "Join", "(", "types", ".", "StreamName", "(", "ls", ".", "Name", ")", ")", ")", "\n", "link", ":=", "ui", ".", "NewLink", "(", "l", ".", "Label", ",", "u", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "l", ".", "Label", ")", ")", "\n", "if", "link", ".", "Label", "==", "\"", "\"", "{", "link", ".", "Label", "=", "ls", ".", "Name", "\n", "}", "\n", "return", "link", "\n\n", "case", "*", "miloProto", ".", "Link_Url", ":", "link", ":=", "ui", ".", "NewLink", "(", "l", ".", "Label", ",", "t", ".", "Url", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "l", ".", "Label", ")", ")", "\n", "if", "link", ".", "Label", "==", "\"", "\"", "{", "link", ".", "Label", "=", "\"", "\"", "\n", "}", "\n", "return", "link", "\n\n", "default", ":", "// Don't know how to render.", "return", "nil", "\n", "}", "\n", "}" ]

[ "BuildLink", "implements", "URLBuilder", "." ]

[ "func", "GetBuild", "(", "c", "context", ".", "Context", ",", "host", "string", ",", "project", "types", ".", "ProjectName", ",", "path", "types", ".", "StreamPath", ")", "(", "*", "ui", ".", "MiloBuildLegacy", ",", "error", ")", "{", "as", ":=", "AnnotationStream", "{", "Project", ":", "project", ",", "Path", ":", "path", ",", "}", "\n", "if", "err", ":=", "as", ".", "Normalize", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Setup our LogDog client.", "var", "err", "error", "\n", "if", "as", ".", "Client", ",", "err", "=", "NewClient", "(", "c", ",", "host", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "// Load the Milo annotation protobuf from the annotation stream.", "switch", "_", ",", "err", ":=", "as", ".", "Fetch", "(", "c", ")", ";", "errors", ".", "Unwrap", "(", "err", ")", "{", "case", "nil", ",", "errNoEntries", ":", "case", "coordinator", ".", "ErrNoSuchStream", ":", "return", "nil", ",", "grpcutil", ".", "NotFoundTag", ".", "Apply", "(", "err", ")", "\n\n", "case", "coordinator", ".", "ErrNoAccess", ":", "return", "nil", ",", "grpcutil", ".", "PermissionDeniedTag", ".", "Apply", "(", "err", ")", "\n\n", "case", "errNotMilo", ",", "errNotDatagram", ":", "// The user requested a LogDog url that isn't a Milo annotation.", "return", "nil", ",", "grpcutil", ".", "InvalidArgumentTag", ".", "Apply", "(", "err", ")", "\n\n", "default", ":", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "return", "as", ".", "toMiloBuild", "(", "c", ")", ",", "nil", "\n", "}" ]

[ "GetBuild", "returns", "a", "build", "from", "a", "raw", "annotation", "stream", "." ]

[ "func", "ReadAnnotations", "(", "c", "context", ".", "Context", ",", "addr", "*", "types", ".", "StreamAddr", ")", "(", "*", "miloProto", ".", "Step", ",", "error", ")", "{", "log", ".", "Infof", "(", "c", ",", "\"", "\"", ",", "addr", ")", "\n\n", "client", ",", "err", ":=", "NewClient", "(", "c", ",", "addr", ".", "Host", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "as", ":=", "AnnotationStream", "{", "Client", ":", "client", ",", "Project", ":", "addr", ".", "Project", ",", "Path", ":", "addr", ".", "Path", ",", "}", "\n", "if", "err", ":=", "as", ".", "Normalize", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "return", "as", ".", "Fetch", "(", "c", ")", "\n", "}" ]

[ "ReadAnnotations", "synchronously", "reads", "and", "decodes", "the", "latest", "Step", "information", "from", "the", "provided", "StreamAddr", "." ]

[ "func", "Stop", "(", ")", "{", "// Wait for on-going traces.", "globals", ".", "wg", ".", "Wait", "(", ")", "\n", "globals", ".", "lockWriter", ".", "Lock", "(", ")", "\n", "defer", "globals", ".", "lockWriter", ".", "Unlock", "(", ")", "\n", "globals", ".", "lockContexts", ".", "Lock", "(", ")", "\n", "defer", "globals", ".", "lockContexts", ".", "Unlock", "(", ")", "\n", "if", "globals", ".", "out", "!=", "nil", "{", "// TODO(maruel): Dump all the stack frames.", "_", ",", "_", "=", "globals", ".", "out", ".", "Write", "(", "footerEvents", ")", "\n", "}", "\n", "globals", ".", "lockID", ".", "Lock", "(", ")", "\n", "defer", "globals", ".", "lockID", ".", "Unlock", "(", ")", "\n", "globals", ".", "out", "=", "nil", "\n", "globals", ".", "contexts", "=", "nil", "\n", "globals", ".", "nextPID", "=", "0", "\n", "globals", ".", "nextID", "=", "0", "\n\n", "// Lower back clock frequency once we're done.", "lowerClockFrequency", "(", ")", "\n", "}" ]

[ "Stop", "stops", "the", "trace", ".", "It", "is", "important", "to", "call", "it", "so", "the", "trace", "file", "is", "properly", "formatted", ".", "Tracing", "events", "after", "this", "call", "are", "ignored", "." ]

[ "func", "Span", "(", "marker", "interface", "{", "}", ",", "name", "string", ",", "args", "Args", ")", "func", "(", "args", "Args", ")", "{", "c", ":=", "getContext", "(", "marker", ")", "\n", "if", "c", "==", "nil", "{", "return", "dummy", "\n", "}", "\n", "tsStart", ":=", "time", ".", "Since", "(", "consts", ".", "start", ")", "\n", "return", "func", "(", "argsEnd", "Args", ")", "{", "tsEnd", ":=", "time", ".", "Since", "(", "consts", ".", "start", ")", "\n", "if", "tsEnd", "==", "tsStart", "{", "// Make sure a duration event lasts at least one nanosecond.", "// It is a problem on systems with very low resolution clock", "// like Windows where the clock is so coarse that a large", "// number of events would not show up on the UI.", "tsEnd", "++", "\n", "}", "\n", "// Use a pair of eventBegin/eventEnd.", "// getID() is a locking call.", "id", ":=", "getID", "(", ")", "\n", "// Remove once https://github.com/google/trace-viewer/issues/963 is rolled", "// into Chrome stable.", "if", "args", "==", "nil", "{", "args", "=", "consts", ".", "fakeArgs", "\n", "}", "\n", "if", "argsEnd", "==", "nil", "{", "argsEnd", "=", "consts", ".", "fakeArgs", "\n", "}", "\n", "c", ".", "emit", "(", "&", "event", "{", "Type", ":", "eventNestableBegin", ",", "Category", ":", "\"", "\"", ",", "Name", ":", "name", ",", "Args", ":", "args", ",", "Timestamp", ":", "fromDuration", "(", "tsStart", ")", ",", "ID", ":", "id", ",", "}", ")", "\n", "c", ".", "emit", "(", "&", "event", "{", "Type", ":", "eventNestableEnd", ",", "Category", ":", "\"", "\"", ",", "Name", ":", "name", ",", "Args", ":", "argsEnd", ",", "Timestamp", ":", "fromDuration", "(", "tsEnd", ")", ",", "ID", ":", "id", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "Span", "defines", "an", "event", "with", "a", "duration", ".", "The", "caller", "MUST", "call", "the", "returned", "callback", "to", "close", "the", "event", ".", "The", "callback", "doesn", "t", "need", "to", "be", "called", "from", "the", "same", "goroutine", "as", "the", "initial", "caller", "." ]

[ "func", "Instant", "(", "marker", "interface", "{", "}", ",", "name", "string", ",", "s", "Scope", ",", "args", "Args", ")", "{", "if", "c", ":=", "getContext", "(", "marker", ")", ";", "c", "!=", "nil", "{", "if", "args", "==", "nil", "{", "args", "=", "consts", ".", "fakeArgs", "\n", "}", "\n", "// getID() is a locking call.", "c", ".", "emit", "(", "&", "event", "{", "Type", ":", "eventNestableInstant", ",", "Category", ":", "\"", "\"", ",", "Name", ":", "name", ",", "Scope", ":", "s", ",", "Args", ":", "args", ",", "ID", ":", "getID", "(", ")", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "Instant", "registers", "an", "intantaneous", "event", "that", "has", "no", "duration", "." ]

[ "func", "CounterSet", "(", "marker", "interface", "{", "}", ",", "name", "string", ",", "value", "float64", ")", "{", "if", "c", ":=", "getContext", "(", "marker", ")", ";", "c", "!=", "nil", "{", "// Sets ID so operations can be ordered.", "c", ".", "lock", ".", "Lock", "(", ")", "\n", "c", ".", "counters", "[", "name", "]", "=", "value", "\n", "c", ".", "lock", ".", "Unlock", "(", ")", "\n", "c", ".", "emit", "(", "&", "event", "{", "Type", ":", "eventCounter", ",", "Name", ":", "name", ",", "Args", ":", "Args", "{", "\"", "\"", ":", "value", "}", ",", "ID", ":", "getID", "(", ")", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "CounterSet", "registers", "a", "new", "value", "for", "a", "counter", ".", "The", "values", "will", "be", "grouped", "inside", "the", "PID", "and", "each", "name", "displayed", "as", "a", "separate", "line", "." ]

[ "func", "NewPID", "(", "marker", "interface", "{", "}", ",", "pname", "string", ")", "{", "globals", ".", "lockContexts", ".", "Lock", "(", ")", "\n", "defer", "globals", ".", "lockContexts", ".", "Unlock", "(", ")", "\n", "if", "globals", ".", "contexts", "==", "nil", "{", "return", "\n", "}", "\n", "newPID", ":=", "globals", ".", "nextPID", "\n", "globals", ".", "nextPID", "++", "\n", "c", ":=", "&", "context", "{", "pid", ":", "newPID", ",", "counters", ":", "map", "[", "string", "]", "float64", "{", "}", "}", "\n", "globals", ".", "contexts", "[", "marker", "]", "=", "c", "\n", "if", "pname", "!=", "\"", "\"", "{", "c", ".", "metadata", "(", "processName", ",", "Args", "{", "\"", "\"", ":", "pname", "}", ")", "\n", "}", "\n", "}" ]

[ "NewPID", "assigns", "a", "pseudo", "-", "process", "ID", "for", "this", "marker", "and", "TID", "1", ".", "Optionally", "assigns", "name", "to", "the", "process", ".", "The", "main", "use", "is", "to", "create", "a", "logical", "group", "for", "events", "." ]

[ "func", "Discard", "(", "marker", "interface", "{", "}", ")", "{", "globals", ".", "lockContexts", ".", "Lock", "(", ")", "\n", "defer", "globals", ".", "lockContexts", ".", "Unlock", "(", ")", "\n", "delete", "(", "globals", ".", "contexts", ",", "marker", ")", "\n", "}" ]

[ "Discard", "forgets", "a", "context", "association", "created", "with", "NewPID", ".", "If", "not", "called", "contexts", "accumulates", "and", "form", "a", "memory", "leak", "." ]

[ "func", "(", "c", "*", "context", ")", "emit", "(", "e", "*", "event", ")", "{", "if", "e", ".", "Timestamp", "==", "0", "{", "e", ".", "Timestamp", "=", "fromDuration", "(", "time", ".", "Since", "(", "consts", ".", "start", ")", ")", "\n", "}", "\n", "// sync.WaitGroup.Add() use atomic.AddUint64().", "globals", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "defer", "globals", ".", "wg", ".", "Done", "(", ")", "\n", "e", ".", "Pid", "=", "c", ".", "pid", "\n", "e", ".", "Tid", "=", "1", "\n", "// Locking is done in a goroutine to not create implicit synchronization", "// when tracing.", "globals", ".", "lockWriter", ".", "Lock", "(", ")", "\n", "defer", "globals", ".", "lockWriter", ".", "Unlock", "(", ")", "\n", "if", "globals", ".", "out", "!=", "nil", "{", "if", "globals", ".", "first", "{", "globals", ".", "first", "=", "false", "\n", "}", "else", "{", "// Writing is done in a goroutine to reduce cost.", "if", "_", ",", "err", ":=", "globals", ".", "out", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "go", "Stop", "(", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "globals", ".", "encoder", ".", "Encode", "(", "e", ")", ";", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "go", "Stop", "(", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "emit", "asynchronously", "emits", "a", "trace", "event", "." ]

[ "func", "(", "c", "*", "context", ")", "metadata", "(", "m", "metadataType", ",", "args", "Args", ")", "{", "c", ".", "emit", "(", "&", "event", "{", "Type", ":", "eventMetadata", ",", "Name", ":", "string", "(", "m", ")", ",", "Args", ":", "args", "}", ")", "\n", "}" ]

[ "metadata", "registers", "metadata", "in", "the", "trace", ".", "For", "example", "putting", "a", "name", "on", "the", "current", "pseudo", "process", "id", "or", "pseudo", "thread", "id", "." ]

[ "func", "Find", "(", "c", "context", ".", "Context", ",", "vers", "Version", ",", "lookPath", "LookPathFunc", ")", "(", "*", "Interpreter", ",", "error", ")", "{", "// pythonM.m, pythonM, python", "searches", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "3", ")", "\n", "pv", ":=", "vers", "\n", "pv", ".", "Patch", "=", "0", "\n", "if", "pv", ".", "Minor", ">", "0", "{", "searches", "=", "append", "(", "searches", ",", "pv", ".", "PythonBase", "(", ")", ")", "\n", "pv", ".", "Minor", "=", "0", "\n", "}", "\n", "if", "pv", ".", "Major", ">", "0", "{", "searches", "=", "append", "(", "searches", ",", "pv", ".", "PythonBase", "(", ")", ")", "\n", "pv", ".", "Major", "=", "0", "\n", "}", "\n", "searches", "=", "append", "(", "searches", ",", "pv", ".", "PythonBase", "(", ")", ")", "\n\n", "lookErrs", ":=", "errors", ".", "NewLazyMultiError", "(", "len", "(", "searches", ")", ")", "\n", "for", "i", ",", "s", ":=", "range", "searches", "{", "interp", ",", "err", ":=", "findInterpreter", "(", "c", ",", "s", ",", "vers", ",", "lookPath", ")", "\n", "if", "err", "==", "nil", "{", "// Resolve to absolute path.", "if", "err", ":=", "filesystem", ".", "AbsPath", "(", "&", "interp", ".", "Python", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "interp", ".", "Python", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "return", "interp", ",", "nil", "\n", "}", "\n\n", "logging", ".", "WithError", "(", "err", ")", ".", "Debugf", "(", "c", ",", "\"", "\"", ",", "s", ")", "\n", "lookErrs", ".", "Assign", "(", "i", ",", "err", ")", "\n", "}", "\n\n", "// No Python interpreter could be identified.", "return", "nil", ",", "errors", ".", "Annotate", "(", "lookErrs", ".", "Get", "(", ")", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}" ]

[ "Find", "attempts", "to", "find", "a", "Python", "interpreter", "matching", "the", "supplied", "version", "using", "PATH", ".", "In", "order", "to", "accommodate", "multiple", "configurations", "on", "operating", "systems", "Find", "will", "attempt", "to", "identify", "versions", "that", "appear", "on", "the", "path" ]

[ "func", "(", "m", "*", "Meta", ")", "Log", "(", "ctx", "context", ".", "Context", ")", "{", "logging", ".", "Debugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "logging", ".", "Debugf", "(", "ctx", ",", "\"", "\"", ",", "m", ".", "ConfigServiceHost", ")", "\n", "logging", ".", "Debugf", "(", "ctx", ",", "\"", "\"", ",", "m", ".", "ConfigDir", ")", "\n", "logging", ".", "Debugf", "(", "ctx", ",", "\"", "\"", ",", "m", ".", "TrackedFiles", ")", "\n", "logging", ".", "Debugf", "(", "ctx", ",", "\"", "\"", ",", "m", ".", "FailOnWarnings", ")", "\n", "}" ]

[ "Log", "logs", "the", "values", "of", "the", "meta", "parameters", "to", "Debug", "logger", "." ]

[ "func", "(", "m", "*", "Meta", ")", "RebaseConfigDir", "(", "root", "string", ")", "{", "if", "m", ".", "ConfigDir", "!=", "\"", "\"", "&&", "m", ".", "ConfigDir", "!=", "\"", "\"", "{", "m", ".", "ConfigDir", "=", "filepath", ".", "Join", "(", "root", ",", "filepath", ".", "FromSlash", "(", "m", ".", "ConfigDir", ")", ")", "\n", "}", "\n", "}" ]

[ "RebaseConfigDir", "changes", "ConfigDir", "if", "it", "is", "set", "to", "be", "absolute", "by", "appending", "it", "to", "the", "given", "root", ".", "Doesn", "t", "touch", "-", "which", "indicates", "stdout", "." ]

[ "func", "(", "m", "*", "Meta", ")", "AddFlags", "(", "fs", "*", "flag", ".", "FlagSet", ")", "{", "m", ".", "fs", "=", "fs", "\n", "fs", ".", "StringVar", "(", "&", "m", ".", "ConfigServiceHost", ",", "\"", "\"", ",", "m", ".", "ConfigServiceHost", ",", "\"", "\"", ")", "\n", "fs", ".", "StringVar", "(", "&", "m", ".", "ConfigDir", ",", "\"", "\"", ",", "m", ".", "ConfigDir", ",", "`A directory to place generated configs into (relative to cwd if given as a\nflag otherwise relative to the main script). If '-', generated configs are just\nprinted to stdout in a format useful for debugging.`", ")", "\n", "fs", ".", "Var", "(", "luciflag", ".", "CommaList", "(", "&", "m", ".", "TrackedFiles", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "fs", ".", "BoolVar", "(", "&", "m", ".", "FailOnWarnings", ",", "\"", "\"", ",", "m", ".", "FailOnWarnings", ",", "\"", "\"", ")", "\n", "}" ]

[ "AddFlags", "registers", "command", "line", "flags", "that", "correspond", "to", "Meta", "fields", "." ]

[ "func", "(", "m", "*", "Meta", ")", "detectTouchedFlags", "(", ")", "{", "switch", "{", "case", "m", ".", "fs", "==", "nil", ":", "return", "// not using CLI flags at all", "\n", "case", "m", ".", "detectedTouchedFlags", ":", "return", "// already did this", "\n", "case", "!", "m", ".", "fs", ".", "Parsed", "(", ")", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "m", ".", "detectedTouchedFlags", "=", "true", "\n\n", "fields", ":=", "m", ".", "fieldsMap", "(", ")", "\n\n", "m", ".", "fs", ".", "Visit", "(", "func", "(", "f", "*", "flag", ".", "Flag", ")", "{", "if", "ptr", ":=", "fields", "[", "strings", ".", "Replace", "(", "f", ".", "Name", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "]", ";", "ptr", "!=", "nil", "{", "m", ".", "touch", "(", "ptr", ")", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "detectTouchedFlags", "is", "called", "after", "flags", "are", "parsed", "to", "figure", "out", "what", "flags", "were", "explicitly", "set", "and", "what", "were", "left", "at", "their", "defaults", ".", "It", "updates", "Meta", "with", "information", "about", "touched", "flags", "which", "is", "later", "used", "by", "PopulateFromTouchedIn", "and", "WasTouched", "functions", "." ]

[ "func", "(", "m", "*", "Meta", ")", "PopulateFromTouchedIn", "(", "t", "*", "Meta", ")", "{", "t", ".", "detectTouchedFlags", "(", ")", "\n", "left", ":=", "m", ".", "fieldsMap", "(", ")", "\n", "right", ":=", "t", ".", "fieldsMap", "(", ")", "\n", "for", "k", ",", "l", ":=", "range", "left", "{", "r", ":=", "right", "[", "k", "]", "\n", "if", "_", ",", "yes", ":=", "t", ".", "touched", "[", "r", "]", ";", "yes", "{", "// Do *l = *r.", "switch", "l", ".", "(", "type", ")", "{", "case", "*", "string", ":", "*", "(", "l", ".", "(", "*", "string", ")", ")", "=", "*", "(", "r", ".", "(", "*", "string", ")", ")", "\n", "case", "*", "bool", ":", "*", "(", "l", ".", "(", "*", "bool", ")", ")", "=", "*", "(", "r", ".", "(", "*", "bool", ")", ")", "\n", "case", "*", "[", "]", "string", ":", "*", "(", "l", ".", "(", "*", "[", "]", "string", ")", ")", "=", "append", "(", "[", "]", "string", "(", "nil", ")", ",", "*", "(", "r", ".", "(", "*", "[", "]", "string", ")", ")", "...", ")", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "PopulateFromTouchedIn", "takes", "all", "touched", "values", "in", "t", "and", "copies", "them", "to", "m", "overriding", "what", "s", "in", "m", "." ]

[ "func", "(", "m", "*", "Meta", ")", "fieldsMap", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "return", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "&", "m", ".", "ConfigServiceHost", ",", "\"", "\"", ":", "&", "m", ".", "ConfigDir", ",", "\"", "\"", ":", "&", "m", ".", "TrackedFiles", ",", "\"", "\"", ":", "&", "m", ".", "FailOnWarnings", ",", "}", "\n", "}" ]

[ "fieldsMap", "returns", "a", "mapping", "from", "a", "snake_case", "name", "of", "a", "field", "to", "a", "pointer", "to", "this", "field", "inside", "m", ".", "This", "is", "used", "by", "both", "Starlark", "accessors", "and", "for", "processing", "CLI", "flags", "." ]

[ "func", "(", "m", "*", "Meta", ")", "setField", "(", "k", "string", ",", "v", "starlark", ".", "Value", ")", "(", "err", "error", ")", "{", "ptr", ":=", "m", ".", "fieldsMap", "(", ")", "[", "k", "]", "\n", "if", "ptr", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n\n", "// On success, mark the field as modified.", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "m", ".", "touch", "(", "ptr", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "switch", "ptr", ":=", "ptr", ".", "(", "type", ")", "{", "case", "*", "string", ":", "if", "str", ",", "ok", ":=", "v", ".", "(", "starlark", ".", "String", ")", ";", "ok", "{", "*", "ptr", "=", "str", ".", "GoString", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ".", "Type", "(", ")", ")", "\n\n", "case", "*", "bool", ":", "if", "b", ",", "ok", ":=", "v", ".", "(", "starlark", ".", "Bool", ")", ";", "ok", "{", "*", "ptr", "=", "bool", "(", "b", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ".", "Type", "(", ")", ")", "\n\n", "case", "*", "[", "]", "string", ":", "if", "iterable", ",", "ok", ":=", "v", ".", "(", "starlark", ".", "Iterable", ")", ";", "ok", "{", "iter", ":=", "iterable", ".", "Iterate", "(", ")", "\n", "defer", "iter", ".", "Done", "(", ")", "\n\n", "var", "vals", "[", "]", "string", "\n", "for", "x", ":=", "starlark", ".", "Value", "(", "nil", ")", ";", "iter", ".", "Next", "(", "&", "x", ")", ";", "{", "if", "str", ",", "ok", ":=", "x", ".", "(", "starlark", ".", "String", ")", ";", "ok", "{", "vals", "=", "append", "(", "vals", ",", "str", ".", "GoString", "(", ")", ")", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "x", ".", "Type", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "*", "ptr", "=", "vals", "\n", "return", "nil", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ".", "Type", "(", ")", ")", "\n\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "setField", "sets", "the", "field", "k", "to", "v", "." ]

[ "func", "(", "g", "*", "GraphQuery", ")", "Normalize", "(", ")", "error", "{", "if", "err", ":=", "g", ".", "AttemptList", ".", "Normalize", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "len", "(", "g", ".", "AttemptRange", ")", ">", "0", "{", "lme", ":=", "errors", ".", "NewLazyMultiError", "(", "len", "(", "g", ".", "AttemptRange", ")", ")", "\n", "for", "i", ",", "rng", ":=", "range", "g", ".", "AttemptRange", "{", "lme", ".", "Assign", "(", "i", ",", "rng", ".", "Normalize", "(", ")", ")", "\n", "}", "\n", "if", "err", ":=", "lme", ".", "Get", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "len", "(", "g", ".", "Search", ")", ">", "0", "{", "lme", ":=", "errors", ".", "NewLazyMultiError", "(", "len", "(", "g", ".", "Search", ")", ")", "\n", "for", "i", ",", "s", ":=", "range", "g", ".", "Search", "{", "lme", ".", "Assign", "(", "i", ",", "s", ".", "Normalize", "(", ")", ")", "\n", "}", "\n", "if", "err", ":=", "lme", ".", "Get", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "returns", "an", "error", "iff", "this", "GraphQuery", "is", "not", "valid", "." ]

[ "func", "(", "al", "*", "GraphQuery_AttemptRange", ")", "Normalize", "(", ")", "error", "{", "if", "al", ".", "Quest", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "al", ".", "Low", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "al", ".", "High", "<=", "al", ".", "Low", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "returns", "nil", "iff", "this", "AttemptRange", "is", "in", "a", "bad", "state", "." ]

[ "func", "(", "s", "*", "GraphQuery_Search", ")", "Normalize", "(", ")", "error", "{", "// for now, start and end MUST be timestamp values.", "switch", "s", ".", "Start", ".", "Value", ".", "(", "type", ")", "{", "case", "*", "PropertyValue_Time", ":", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "Start", ".", "Value", ")", "\n", "}", "\n", "switch", "s", ".", "End", ".", "Value", ".", "(", "type", ")", "{", "case", "*", "PropertyValue_Time", ":", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "End", ".", "Value", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Normalize", "returns", "nil", "iff", "this", "Search", "is", "in", "a", "bad", "state", "." ]

[ "func", "tumbleNow", "(", "c", "context", ".", "Context", ",", "m", "tumble", ".", "Mutation", ")", "error", "{", "err", ":=", "tumble", ".", "RunMutation", "(", "c", ",", "m", ")", "\n", "if", "grpc", ".", "Code", "(", "err", ")", "==", "codes", ".", "Unknown", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "m", ")", "\n", "err", "=", "grpcutil", ".", "Internal", "\n", "}", "\n", "logging", ".", "Fields", "{", "\"", "\"", ":", "m", ".", "Root", "(", "c", ")", "}", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "return", "err", "\n", "}" ]

[ "tumbleNow", "will", "run", "the", "mutation", "immediately", "converting", "any", "non", "grpc", "errors", "to", "codes", ".", "Internal", "." ]

[ "func", "(", "v", "*", "Context", ")", "Errorf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "v", ".", "Error", "(", "errors", ".", "Reason", "(", "format", ",", "args", "...", ")", ".", "Err", "(", ")", ")", "\n", "}" ]

[ "Errorf", "records", "the", "given", "format", "string", "and", "args", "as", "a", "validation", "error", "." ]

[ "func", "(", "v", "*", "Context", ")", "Error", "(", "err", "error", ")", "{", "ctx", ":=", "\"", "\"", "\n", "if", "v", ".", "file", "!=", "\"", "\"", "{", "ctx", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ".", "file", ")", "\n", "}", "else", "{", "ctx", "=", "\"", "\"", "\n", "}", "\n", "if", "len", "(", "v", ".", "element", ")", "!=", "0", "{", "ctx", "+=", "\"", "\"", "+", "strings", ".", "Join", "(", "v", ".", "element", ",", "\"", "\"", ")", "+", "\"", "\"", "\n", "}", "\n", "// Make the file and the logical path also usable through error inspection.", "err", "=", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "ctx", ")", ".", "Tag", "(", "fileTag", ".", "With", "(", "v", ".", "file", ")", ",", "elementTag", ".", "With", "(", "v", ".", "element", ")", ")", ".", "Err", "(", ")", "\n", "v", ".", "errors", "=", "append", "(", "v", ".", "errors", ",", "err", ")", "\n", "}" ]

[ "Error", "records", "the", "given", "error", "as", "a", "validation", "error", "." ]

[ "func", "(", "v", "*", "Context", ")", "Enter", "(", "title", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "e", ":=", "fmt", ".", "Sprintf", "(", "title", ",", "args", "...", ")", "\n", "v", ".", "element", "=", "append", "(", "v", ".", "element", ",", "e", ")", "\n", "}" ]

[ "Enter", "descends", "into", "a", "sub", "-", "element", "when", "validating", "a", "nested", "structure", ".", "Useful", "for", "defining", "context", ".", "A", "current", "path", "of", "elements", "shows", "up", "in", "validation", "messages", ".", "The", "reverse", "is", "Exit", "." ]

[ "func", "(", "v", "*", "Context", ")", "Exit", "(", ")", "{", "if", "len", "(", "v", ".", "element", ")", "!=", "0", "{", "v", ".", "element", "=", "v", ".", "element", "[", ":", "len", "(", "v", ".", "element", ")", "-", "1", "]", "\n", "}", "\n", "}" ]

[ "Exit", "pops", "the", "current", "element", "we", "are", "visiting", "from", "the", "stack", ".", "This", "is", "the", "reverse", "of", "Enter", ".", "Each", "Enter", "must", "have", "corresponding", "Exit", ".", "Use", "functions", "and", "defers", "to", "ensure", "this", "if", "it", "s", "otherwise", "hard", "to", "track", "." ]

[ "func", "(", "t", "*", "TimeOfDay", ")", "toTime", "(", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "now", ":=", "time", ".", "Time", "{", "}", "\n", "loc", ",", "err", ":=", "time", ".", "LoadLocation", "(", "t", ".", "GetLocation", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "now", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "now", "=", "now", ".", "In", "(", "loc", ")", "\n", "// Decompose the time into a slice of [time, <hour>, <minute>].", "m", ":=", "regexp", ".", "MustCompile", "(", "timeRegex", ")", ".", "FindStringSubmatch", "(", "t", ".", "GetTime", "(", ")", ")", "\n", "if", "len", "(", "m", ")", "!=", "3", "{", "return", "now", ",", "errors", ".", "Reason", "(", "\"", "\"", ",", "timeRegex", ")", ".", "Err", "(", ")", "\n", "}", "\n", "hr", ",", "err", ":=", "strconv", ".", "Atoi", "(", "m", "[", "1", "]", ")", "\n", "if", "err", "!=", "nil", "||", "hr", ">", "23", "{", "return", "now", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "min", ",", "err", ":=", "strconv", ".", "Atoi", "(", "m", "[", "2", "]", ")", "\n", "if", "err", "!=", "nil", "||", "min", ">", "59", "{", "return", "now", ",", "errors", ".", "Reason", "(", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "time", ".", "Date", "(", "now", ".", "Year", "(", ")", ",", "now", ".", "Month", "(", ")", ",", "now", ".", "Day", "(", ")", ",", "hr", ",", "min", ",", "0", ",", "0", ",", "loc", ")", ",", "nil", "\n", "}" ]

[ "toTime", "returns", "the", "time", ".", "Time", "representation", "of", "the", "time", "referenced", "by", "this", "time", "of", "day", "." ]

[ "func", "(", "t", "*", "TimeOfDay", ")", "Validate", "(", "c", "*", "validation", ".", "Context", ")", "{", "if", "t", ".", "GetDay", "(", ")", "==", "dayofweek", ".", "DayOfWeek_DAY_OF_WEEK_UNSPECIFIED", "{", "c", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "_", ",", "err", ":=", "t", ".", "toTime", "(", ")", "\n", "if", "err", "!=", "nil", "{", "c", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "Validate", "validates", "this", "time", "of", "day", "." ]

[ "func", "Load", "(", "path", "string", ",", "spec", "*", "vpython", ".", "Spec", ")", "error", "{", "content", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ",", "path", ")", ".", "Err", "(", ")", "\n", "}", "\n\n", "return", "Parse", "(", "string", "(", "content", ")", ",", "spec", ")", "\n", "}" ]

[ "Load", "loads", "an", "specification", "file", "text", "protobuf", "from", "the", "supplied", "path", "." ]

[ "func", "Parse", "(", "content", "string", ",", "spec", "*", "vpython", ".", "Spec", ")", "error", "{", "if", "err", ":=", "cproto", ".", "UnmarshalTextML", "(", "content", ",", "spec", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Parse", "loads", "a", "specification", "message", "from", "a", "content", "string", "." ]

[ "func", "IsEnded", "(", "s", "pb", ".", "Status", ")", "bool", "{", "return", "s", "&", "pb", ".", "Status_ENDED_MASK", "==", "pb", ".", "Status_ENDED_MASK", "\n", "}" ]

[ "IsEnded", "returns", "true", "if", "s", "is", "final", "." ]

[ "func", "(", "s", "*", "Server", ")", "serve", "(", "cb", "ServeFunc", ")", "error", "{", "s", ".", "l", ".", "Lock", "(", ")", "\n", "if", "s", ".", "listener", "==", "nil", "{", "s", ".", "l", ".", "Unlock", "(", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "listener", ":=", "s", ".", "listener", "// accessed outside the lock", "\n", "ctx", ":=", "s", ".", "ctx", "\n", "s", ".", "l", ".", "Unlock", "(", ")", "\n\n", "err", ":=", "cb", "(", "ctx", ",", "listener", ",", "&", "s", ".", "wg", ")", "// blocks until killServe() is called", "\n", "s", ".", "wg", ".", "Wait", "(", ")", "// waits for all pending requests", "\n\n", "// If it was a planned shutdown with killServe(), ignore the error. It says", "// that the listening socket was closed.", "s", ".", "l", ".", "Lock", "(", ")", "\n", "if", "s", ".", "listener", "==", "nil", "{", "err", "=", "nil", "\n", "}", "\n", "s", ".", "l", ".", "Unlock", "(", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "serve", "runs", "the", "serving", "loop", ".", "It", "unblocks", "once", "killServe", "is", "called", "and", "all", "pending", "requests", "are", "served", ".", "Returns", "nil", "if", "serving", "was", "stopped", "by", "killServe", "or", "non", "-", "nil", "if", "it", "failed", "for", "some", "other", "reason", "." ]

[ "func", "InstallHandlers", "(", "r", "*", "router", ".", "Router", ",", "base", "router", ".", "MiddlewareChain", ")", "{", "r", ".", "GET", "(", "\"", "\"", ",", "base", ".", "Extend", "(", "gaemiddleware", ".", "RequireCron", ")", ",", "housekeepingHandler", ")", "\n", "}" ]

[ "InstallHandlers", "installs", "HTTP", "handlers", "for", "tsmon", "routes", "." ]

[ "func", "housekeepingHandler", "(", "c", "*", "router", ".", "Context", ")", "{", "tsmon", ".", "GetState", "(", "c", ".", "Context", ")", ".", "RunGlobalCallbacks", "(", "c", ".", "Context", ")", "\n", "if", "err", ":=", "AssignTaskNumbers", "(", "c", ".", "Context", ")", ";", "err", "!=", "nil", "{", "logging", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "c", ".", "Context", ",", "\"", "\"", ")", "\n", "c", ".", "Writer", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "}", "\n", "}" ]

[ "housekeepingHandler", "performs", "task", "number", "assignments", "and", "runs", "global", "metric", "callbacks", ".", "See", "DatastoreTaskNumAllocator", "and", "AssignTaskNumbers", "." ]

[ "func", "(", "cmd", "*", "createSnapshotCmd", ")", "validateFlags", "(", "c", "context", ".", "Context", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "if", "cmd", ".", "disk", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "labels", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "cmd", ".", "labels", ")", ")", "\n", "for", "_", ",", "label", ":=", "range", "cmd", ".", "labels", "{", "parts", ":=", "strings", ".", "SplitN", "(", "label", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "return", "nil", ",", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "label", ")", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "labels", "[", "parts", "[", "0", "]", "]", ";", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "label", ")", ")", "\n", "}", "\n", "labels", "[", "parts", "[", "0", "]", "]", "=", "parts", "[", "1", "]", "\n", "}", "\n", "if", "cmd", ".", "name", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cmd", ".", "project", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cmd", ".", "zone", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "labels", ",", "nil", "\n", "}" ]

[ "validateFlags", "validates", "parsed", "command", "line", "flags", "and", "returns", "a", "map", "of", "parsed", "labels", "." ]

[ "func", "(", "cmd", "*", "createSnapshotCmd", ")", "Run", "(", "app", "subcommands", ".", "Application", ",", "args", "[", "]", "string", ",", "env", "subcommands", ".", "Env", ")", "int", "{", "c", ":=", "cli", ".", "GetContext", "(", "app", ",", "cmd", ",", "env", ")", "\n", "labels", ",", "err", ":=", "cmd", ".", "validateFlags", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "1", "\n", "}", "\n\n", "srv", ":=", "getService", "(", "c", ")", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "snapshot", ":=", "&", "compute", ".", "Snapshot", "{", "Labels", ":", "labels", ",", "Name", ":", "cmd", ".", "name", ",", "}", "\n", "op", ",", "err", ":=", "compute", ".", "NewDisksService", "(", "srv", ")", ".", "CreateSnapshot", "(", "cmd", ".", "project", ",", "cmd", ".", "zone", ",", "cmd", ".", "disk", ",", "snapshot", ")", ".", "Context", "(", "c", ")", ".", "Do", "(", ")", "\n", "for", "{", "if", "err", "!=", "nil", "{", "for", "_", ",", "err", ":=", "range", "err", ".", "(", "*", "googleapi", ".", "Error", ")", ".", "Errors", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "err", ".", "Message", ")", "\n", "}", "\n", "return", "1", "\n", "}", "\n", "if", "op", ".", "Status", "==", "\"", "\"", "{", "break", "\n", "}", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "time", ".", "Sleep", "(", "2", "*", "time", ".", "Second", ")", "\n", "op", ",", "err", "=", "compute", ".", "NewZoneOperationsService", "(", "srv", ")", ".", "Get", "(", "cmd", ".", "project", ",", "cmd", ".", "zone", ",", "op", ".", "Name", ")", ".", "Context", "(", "c", ")", ".", "Do", "(", ")", "\n", "}", "\n", "if", "op", ".", "Error", "!=", "nil", "{", "for", "_", ",", "err", ":=", "range", "op", ".", "Error", ".", "Errors", "{", "logging", ".", "Errorf", "(", "c", ",", "\"", "\"", ",", "err", ".", "Message", ")", "\n", "}", "\n", "return", "1", "\n", "}", "\n", "logging", ".", "Infof", "(", "c", ",", "\"", "\"", ")", "\n", "return", "0", "\n", "}" ]

[ "Run", "runs", "the", "command", "to", "create", "a", "disk", "snapshot", "." ]

[ "func", "getCreateSnapshotCmd", "(", ")", "*", "subcommands", ".", "Command", "{", "return", "&", "subcommands", ".", "Command", "{", "UsageLine", ":", "\"", "\"", ",", "ShortDesc", ":", "\"", "\"", ",", "LongDesc", ":", "\"", "\"", ",", "CommandRun", ":", "func", "(", ")", "subcommands", ".", "CommandRun", "{", "cmd", ":=", "&", "createSnapshotCmd", "{", "}", "\n", "cmd", ".", "Initialize", "(", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "disk", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "Var", "(", "flag", ".", "StringSlice", "(", "&", "cmd", ".", "labels", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "name", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "project", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Flags", ".", "StringVar", "(", "&", "cmd", ".", "zone", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}", ",", "}", "\n", "}" ]

[ "getCreateSnapshotCmd", "returns", "a", "new", "command", "to", "create", "a", "snapshot", "." ]

[ "func", "shouldRetry", "(", "c", "context", ".", "Context", ",", "a", "*", "model", ".", "Attempt", ",", "stat", "dm", ".", "AbnormalFinish_Status", ")", "(", "retry", "bool", ",", "err", "error", ")", "{", "if", "!", "stat", ".", "CouldRetry", "(", ")", "{", "return", "\n", "}", "\n", "q", ":=", "model", ".", "QuestFromID", "(", "a", ".", "ID", ".", "Quest", ")", "\n\n", "if", "err", "=", "ds", ".", "Get", "(", "ds", ".", "WithoutTransaction", "(", "c", ")", ",", "q", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "var", "cur", ",", "max", "uint32", "\n", "switch", "stat", "{", "case", "dm", ".", "AbnormalFinish_FAILED", ":", "cur", ",", "max", "=", "a", ".", "RetryState", ".", "Failed", ",", "q", ".", "Desc", ".", "Meta", ".", "Retry", ".", "Failed", "\n", "a", ".", "RetryState", ".", "Failed", "++", "\n", "case", "dm", ".", "AbnormalFinish_CRASHED", ":", "cur", ",", "max", "=", "a", ".", "RetryState", ".", "Crashed", ",", "q", ".", "Desc", ".", "Meta", ".", "Retry", ".", "Crashed", "\n", "a", ".", "RetryState", ".", "Crashed", "++", "\n", "case", "dm", ".", "AbnormalFinish_EXPIRED", ":", "cur", ",", "max", "=", "a", ".", "RetryState", ".", "Expired", ",", "q", ".", "Desc", ".", "Meta", ".", "Retry", ".", "Expired", "\n", "a", ".", "RetryState", ".", "Expired", "++", "\n", "case", "dm", ".", "AbnormalFinish_TIMED_OUT", ":", "cur", ",", "max", "=", "a", ".", "RetryState", ".", "TimedOut", ",", "q", ".", "Desc", ".", "Meta", ".", "Retry", ".", "TimedOut", "\n", "a", ".", "RetryState", ".", "TimedOut", "++", "\n", "default", ":", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "stat", ")", ")", "\n", "}", "\n", "retry", "=", "cur", "<", "max", "\n", "return", "\n", "}" ]

[ "shouldRetry", "loads", "the", "quest", "for", "this", "attempt", "to", "determine", "if", "the", "attempt", "can", "be", "retried", ".", "As", "a", "side", "-", "effect", "it", "increments", "the", "RetryState", "counter", "for", "the", "indicated", "failure", "type", ".", "If", "stat", "is", "not", "a", "retryable", "AbnormalFinish_Status", "this", "will", "panic", "." ]